From 0e12be8b663d58f7a9629ff0fced570e3524bfc7 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Thu, 21 Feb 2013 11:17:53 +0100
Subject: [PATCH 001/354] [Johnny Clasrk] IsNull IsNotNull True False Checks
 and Assertions (IDEA-35808)

---
 .../codeInsight/ConditionCheckManager.java    | 252 +++++++
 .../codeInsight/ConditionChecker.java         |  55 ++
 .../codeInsight/MethodConditionCheck.java     | 396 +++++++++++
 .../dataFlow/ConditionCheckDialog.java        | 264 ++++++++
 .../dataFlow/ControlFlowAnalyzer.java         |  77 +++
 .../dataFlow/DataFlowInspection.java          |  18 +
 .../dataFlow/MethodCheckerDetailsDialog.java  | 621 ++++++++++++++++++
 .../dataFlow/fixture/AssertFalse.java         |   9 +
 .../dataFlow/fixture/AssertIsNotNull.java     |  10 +
 .../dataFlow/fixture/AssertIsNull.java        |  10 +
 .../dataFlow/fixture/AssertTrue.java          |   9 +
 .../dataFlow/fixture/IsNotNullCheck.java      |   9 +
 .../dataFlow/fixture/IsNullCheck.java         |   9 +
 .../DataFlowInspectionTest.java               |  63 ++
 .../src/messages/InspectionsBundle.properties |  16 +
 resources/src/META-INF/IdeaPlugin.xml         |   3 +
 16 files changed, 1821 insertions(+)
 create mode 100644 java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
 create mode 100644 java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
 create mode 100644 java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
 create mode 100644 java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
 create mode 100644 java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/AssertFalse.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNotNull.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNull.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/AssertTrue.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/IsNotNullCheck.java
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/IsNullCheck.java

diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
new file mode 100644
index 000000000000..539a3a1b231a
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
@@ -0,0 +1,252 @@
+/*
+ * 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.codeInsight;
+
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiMethod;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
+ *         Creation Date: 8/3/12
+ */
+@State(
+  name = "IsNullIsNotNullCheckManager",
+  storages = {@Storage(id = "dir", file = StoragePathMacros.PROJECT_CONFIG_DIR + "/checker.xml", scheme = StorageScheme.DIRECTORY_BASED)}
+)
+public class ConditionCheckManager implements PersistentStateComponent<ConditionCheckManager.State> {
+  @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) private State state;
+  private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.ConditionCheckManager");
+
+  private List<MethodConditionCheck> myIsNullCheckMethods = new ArrayList<MethodConditionCheck>();
+  private List<MethodConditionCheck> myIsNotNullCheckMethods = new ArrayList<MethodConditionCheck>();
+
+  private List<MethodConditionCheck> myAssertIsNullMethods = new ArrayList<MethodConditionCheck>();
+  private List<MethodConditionCheck> myAssertIsNotNullMethods = new ArrayList<MethodConditionCheck>();
+
+  private List<MethodConditionCheck> myAssertTrueMethods = new ArrayList<MethodConditionCheck>();
+  private List<MethodConditionCheck> myAssertFalseMethods = new ArrayList<MethodConditionCheck>();
+
+  private static Project myProject;
+
+  public static ConditionCheckManager getInstance(Project project) {
+    myProject = project;
+    return ServiceManager.getService(project, ConditionCheckManager.class);
+  }
+
+  public void setIsNullCheckMethods(List<MethodConditionCheck> methodConditionChecks) {
+    myIsNullCheckMethods.clear();
+    myIsNullCheckMethods.addAll(methodConditionChecks);
+  }
+
+  public void setIsNotNullCheckMethods(List<MethodConditionCheck> methodConditionChecks) {
+    myIsNotNullCheckMethods.clear();
+    myIsNotNullCheckMethods.addAll(methodConditionChecks);
+  }
+
+  public void setAssertNullMethods(List<MethodConditionCheck> methodConditionChecks) {
+    myAssertIsNullMethods.clear();
+    myAssertIsNullMethods.addAll(methodConditionChecks);
+  }
+
+  public void setAssertNotNullMethods(List<MethodConditionCheck> methodConditionChecks) {
+    myAssertIsNotNullMethods.clear();
+    myAssertIsNotNullMethods.addAll(methodConditionChecks);
+  }
+
+  public void setAssertTrueMethods(List<MethodConditionCheck> psiMethodWrappers) {
+    myAssertTrueMethods.clear();
+    myAssertTrueMethods.addAll(psiMethodWrappers);
+  }
+
+  public void setAssertFalseMethods(List<MethodConditionCheck> psiMethodWrappers) {
+    myAssertFalseMethods.clear();
+    myAssertFalseMethods.addAll(psiMethodWrappers);
+  }
+
+  public List<MethodConditionCheck> getIsNullCheckMethods() {
+    return myIsNullCheckMethods;
+  }
+
+  public List<MethodConditionCheck> getIsNotNullCheckMethods() {
+    return myIsNotNullCheckMethods;
+  }
+
+  public List<MethodConditionCheck> getAssertIsNullMethods() {
+    return myAssertIsNullMethods;
+  }
+
+  public List<MethodConditionCheck> getAssertIsNotNullMethods() {
+    return myAssertIsNotNullMethods;
+  }
+
+  public List<MethodConditionCheck> getAssertFalseMethods() {
+    return myAssertFalseMethods;
+  }
+
+  public List<MethodConditionCheck> getAssertTrueMethods() {
+    return myAssertTrueMethods;
+  }
+
+  public static class State {
+    public List<String> myIsNullCheckMethods = new ArrayList<String>();
+    public List<String> myIsNotNullCheckMethods = new ArrayList<String>();
+    public List<String> myAssertIsNullMethods = new ArrayList<String>();
+    public List<String> myAssertIsNotNullMethods = new ArrayList<String>();
+    public List<String> myAssertTrueMethods = new ArrayList<String>();
+    public List<String> myAssertFalseMethods = new ArrayList<String>();
+  }
+
+  @Override
+  public State getState() {
+    State state = new State();
+
+    loadMethodChecksToState(state.myIsNullCheckMethods, myIsNullCheckMethods);
+    loadMethodChecksToState(state.myIsNotNullCheckMethods, myIsNotNullCheckMethods);
+    loadMethodChecksToState(state.myAssertIsNullMethods, myAssertIsNullMethods);
+    loadMethodChecksToState(state.myAssertIsNotNullMethods, myAssertIsNotNullMethods);
+    loadMethodChecksToState(state.myAssertTrueMethods, myAssertTrueMethods);
+    loadMethodChecksToState(state.myAssertFalseMethods, myAssertFalseMethods);
+
+    return state;
+  }
+
+  private static void loadMethodChecksToState(List<String> listToLoadTo, List<MethodConditionCheck> listToLoadFrom) {
+    for (MethodConditionCheck checker : listToLoadFrom) {
+      listToLoadTo.add(checker.toString());
+    }
+  }
+
+  @Override
+  public void loadState(State state) {
+    this.state = state;
+    loadMethods(myIsNullCheckMethods, state.myIsNullCheckMethods, ConditionChecker.Type.IS_NULL_METHOD);
+    loadMethods(myIsNotNullCheckMethods, state.myIsNotNullCheckMethods, ConditionChecker.Type.IS_NOT_NULL_METHOD);
+    loadMethods(myAssertIsNullMethods, state.myAssertIsNullMethods, ConditionChecker.Type.ASSERT_IS_NULL_METHOD);
+    loadMethods(myAssertIsNotNullMethods, state.myAssertIsNotNullMethods, ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD);
+    loadMethods(myAssertTrueMethods, state.myAssertTrueMethods, ConditionChecker.Type.ASSERT_TRUE_METHOD);
+    loadMethods(myAssertFalseMethods, state.myAssertFalseMethods, ConditionChecker.Type.ASSERT_FALSE_METHOD);
+  }
+
+  public void loadMethods(List<MethodConditionCheck> listToLoadTo, List<String> listToLoadFrom, ConditionChecker.Type type){
+    listToLoadTo.clear();
+    for (String setting : listToLoadFrom) {
+      try {
+        listToLoadTo.add(new MethodConditionCheck.Builder(setting, type, myProject).build());
+      } catch (Exception e) {
+        LOG.error("Problem occurred while attempting to load Condition Check from configuration file. " + e.getMessage());
+      }
+    }
+  }
+
+  public static boolean isMethod(@NotNull PsiMethod psiMethod, List<MethodConditionCheck> checkers) {
+    for (MethodConditionCheck checker : checkers) {
+      if (checker.matches(psiMethod)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public static boolean isCheck(PsiMethod psiMethod) {
+    ConditionCheckManager manager = getInstance(psiMethod.getProject());
+    return isMethod(psiMethod, manager.getIsNullCheckMethods()) ||
+           isMethod(psiMethod, manager.getIsNotNullCheckMethods()) ||
+           isMethod(psiMethod, manager.getAssertIsNullMethods()) ||
+           isMethod(psiMethod, manager.getAssertIsNotNullMethods()) ||
+           isAssertTrueCheckMethod(psiMethod) ||
+           isAssertFalseCheckMethod(psiMethod);
+  }
+
+  public static boolean isNullCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getIsNullCheckMethods());
+  }
+
+  public static boolean isNotNullCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getIsNotNullCheckMethods());
+  }
+
+  public static boolean isAssertIsNullCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getAssertIsNullMethods());
+  }
+
+  public static boolean isAssertIsNotNullCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getAssertIsNotNullMethods());
+  }
+
+  public static boolean isAssertTrueCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getAssertTrueMethods());
+  }
+
+  public static boolean isAssertFalseCheckMethod(PsiMethod psiMethod) {
+    return methodMatches(psiMethod, getInstance(psiMethod.getProject()).getAssertFalseMethods());
+  }
+
+  public static boolean isNullCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getIsNullCheckMethods());
+  }
+
+  public static boolean isNotNullCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getIsNotNullCheckMethods());
+  }
+
+  public static boolean isAssertIsNullCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getAssertIsNullMethods());
+  }
+
+  public static boolean isAssertIsNotNullCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getAssertIsNotNullMethods());
+  }
+
+  public static boolean isAssertTrueCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getAssertTrueMethods());
+  }
+
+  public static boolean isAssertFalseCheckMethod(PsiMethod psiMethod, int paramIndex) {
+    return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getAssertFalseMethods());
+  }
+
+  public static boolean methodMatches(PsiMethod psiMethod, List<MethodConditionCheck> checkers) {
+    for (MethodConditionCheck checker : checkers) {
+      if (checker.matches(psiMethod))
+        return true;
+    }
+    return false;
+  }
+
+  public static boolean methodMatches(PsiMethod psiMethod, int paramIndex, List<MethodConditionCheck> checkers) {
+    for (MethodConditionCheck checker : checkers) {
+      if (checker.matches(psiMethod, paramIndex))
+        return true;
+    }
+    return false;
+  }
+
+  public static boolean isNullCheck(PsiMethod psiMethod) {
+    ConditionCheckManager manager = getInstance(psiMethod.getProject());
+    return isMethod(psiMethod, manager.getIsNullCheckMethods()) || isMethod(psiMethod, manager.getAssertIsNullMethods());
+  }
+
+  public static boolean isNotNullCheck(PsiMethod psiMethod) {
+    ConditionCheckManager manager = getInstance(psiMethod.getProject());
+    return isMethod(psiMethod, manager.getIsNotNullCheckMethods()) || isMethod(psiMethod, manager.getAssertIsNotNullMethods());
+  }
+}
diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
new file mode 100644
index 000000000000..ffcbb3c57558
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
@@ -0,0 +1,55 @@
+/*
+ * 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.codeInsight;
+
+import com.intellij.psi.*;
+
+/**
+ * Interface for IsNull, IsNotNull Method Checks and Assert True/False/IsNull/IsNotNull Method Checks to be performed by the Constant Condition Inspection.
+ * These Checkers allow the user to specify that the method in question performs some type of validation on the parameter passed into the method.
+ * For example, if the method is defined as performing an IsNotNull Check, and variable x is passed into the method, then all code after the method call
+ * will assume that x is Not Null.
+ *
+ * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
+ *         Creation Date: 8/14/12
+ */
+public interface ConditionChecker {
+  enum Type {
+    IS_NULL_METHOD("IsNull Method"),
+    IS_NOT_NULL_METHOD("IsNotNull Method"),
+    ASSERT_IS_NULL_METHOD("Assert IsNull Method"),
+    ASSERT_IS_NOT_NULL_METHOD("Assert IsNotNull Method"),
+    ASSERT_TRUE_METHOD("Assert True Method"),
+    ASSERT_FALSE_METHOD("Assert False Method");
+    private final String myStringRepresentation;
+
+    Type(String stringRepresentation) {
+      myStringRepresentation = stringRepresentation;
+    }
+
+    @Override
+    public String toString() {
+      return myStringRepresentation;
+    }
+  }
+
+  boolean matches(PsiMethod psiMethod);
+  boolean matches(PsiMethod psiMethod, int paramIndex);
+
+  boolean overlaps(ConditionChecker checker);
+
+  Type getType();
+}
diff --git a/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java b/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
new file mode 100644
index 000000000000..b8f1afbf9442
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
@@ -0,0 +1,396 @@
+/*
+ * 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.codeInsight;
+
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import com.intellij.psi.search.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+import static com.intellij.codeInsight.ConditionChecker.Type.*;
+
+/**
+ * Used by Constant Condition Inspection to identify methods which perform some type of Validation on the parameters passed into them.
+ * For example given the following method
+ * <pre>
+ * {@code
+ *  class Foo {
+ *     static boolean validateNotNull(Object o) {
+ *       if (o == null) return false;
+ *       else return true;
+ *     }
+ *   }
+ * }
+ *
+ * The corresponding MethodConditionCheck would be <p/>
+ * myType=Type.IS_NOT_NULL_METHOD
+ * myPsiClass=Foo
+ * myPsiMethod=validateNotNull
+ * myPsiParameter=o
+ *
+ * The following block of code would produce a Inspection Warning that o is always true
+ *
+ *  <pre>
+ * {@code
+ *   if (Value.isNotNull(o)) {
+ *     if(o != null) {}
+ *   }
+ * }
+ * </pre>
+ *
+ * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
+ *         Creation Date: 8/14/12
+ */
+public class MethodConditionCheck implements ConditionChecker, Comparable<MethodConditionCheck> {
+  private final @NotNull Type myType;
+  private final @NotNull PsiClass myPsiClass;
+  private final @NotNull PsiMethod myPsiMethod;
+  private final @NotNull PsiParameter myPsiParameter;
+  private final String fullName;
+  private final String shortName;
+
+  public MethodConditionCheck(@NotNull PsiMethod psiMethod, @NotNull PsiParameter psiParameter, @NotNull Type type) {
+    myPsiMethod = psiMethod;
+    myPsiParameter = psiParameter;
+    if (type != IS_NULL_METHOD && type != IS_NOT_NULL_METHOD &&
+        type != ASSERT_IS_NULL_METHOD && type != ASSERT_IS_NOT_NULL_METHOD &&
+        type != ASSERT_TRUE_METHOD && type != ASSERT_FALSE_METHOD)
+      throw new IllegalArgumentException("Type is invalid " + type);
+
+    PsiClass containingClass = psiMethod.getContainingClass();
+    if (containingClass == null)
+      throw new IllegalArgumentException("PsiMethod has null Containing Class");
+
+    myPsiClass = containingClass;
+    myType = type;
+
+    validatePsiMethod();
+    String className = initClassNameFromPsiMethod();
+    String methodName = initMethodNameFromPsiMethod();
+    List<String> parameters = initParameterNamesFromPsiMethod(myPsiParameter);
+    fullName = initFullName(className, methodName, parameters);
+    shortName = initShortName(methodName, parameters);
+  }
+
+  @Override
+  public boolean matches(PsiMethod psiMethod) {
+    if (myPsiMethod.equals(psiMethod)) {
+      return true;
+    }
+
+    // The equals method in PsiMethod compares to see if they are the same object, but sometimes they are not the same object but do represent the same method
+    if (!myPsiMethod.getName().equals(psiMethod.getName())) return false;
+
+    PsiClass myContainingClass = myPsiMethod.getContainingClass();
+    PsiClass containingClass = myPsiMethod.getContainingClass();
+    if (myContainingClass == null && containingClass != null) return false;
+    if (myContainingClass != null && containingClass == null) return false;
+    if (myContainingClass != null) {   // Both must be non-null
+      String myQualifiedName = myContainingClass.getQualifiedName();
+      String qualifiedName = containingClass.getQualifiedName();
+      if (myQualifiedName == null && qualifiedName != null) return false;
+      if (myQualifiedName != null && qualifiedName == null) return false;
+      if (myQualifiedName != null && !myQualifiedName.equals(qualifiedName)) return false;
+    }
+
+    PsiParameterList myPsiParameterList = myPsiMethod.getParameterList();
+    PsiParameterList psiParameterList = psiMethod.getParameterList();
+    if (myPsiParameterList.getParameters().length != psiParameterList.getParameters().length) return false;
+    for (int i = 0; i < myPsiParameterList.getParameters().length; i++) {
+      PsiParameter myPsiParameter = myPsiParameterList.getParameters()[i];
+      PsiParameter psiParameter = psiParameterList.getParameters()[i];
+      if (myPsiParameter == null && psiParameter != null) return false;
+      if (myPsiParameter != null && psiParameter == null) return false;
+      if (myPsiParameter != null) { // Both must be non-null
+        PsiTypeElement myPsiTypeElement = myPsiParameter.getTypeElement();
+        PsiTypeElement psiTypeElement = psiParameter.getTypeElement();
+        if (myPsiTypeElement == null && psiTypeElement != null) return false;
+        if (myPsiTypeElement != null && psiTypeElement == null) return false;
+        if (myPsiTypeElement != null && myPsiTypeElement.getType() == psiTypeElement.getType()) return false;
+      }
+    }
+
+    return true;
+  }
+
+  @Override
+  public boolean matches(PsiMethod psiMethod, int paramIndex) {
+    if (matches(psiMethod)) {
+      PsiParameter[] parameters = myPsiMethod.getParameterList().getParameters();
+      if (parameters.length <= paramIndex)
+        return false;
+
+      PsiParameter parameter = parameters[paramIndex];
+      if (parameter.equals(myPsiParameter))
+        return true;
+      else
+        return false;
+    }
+
+    return false;
+  }
+
+  @Override
+  public boolean overlaps(ConditionChecker checker) {
+    MethodConditionCheck otherChecker = (MethodConditionCheck) checker;
+    if (myPsiClass.equals(otherChecker.myPsiClass) && myPsiMethod.equals(otherChecker.myPsiMethod) && myPsiParameter.equals(otherChecker.myPsiParameter))
+      return true;
+
+    return false;
+  }
+
+  @Override
+  public Type getType() {
+    return myType;
+  }
+
+  private void validatePsiMethod() {
+    PsiElement psiElement = myPsiMethod.getContainingClass();
+    if (!(psiElement instanceof PsiClass))
+      throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " can not have a null containing class.");
+
+    PsiType returnType = myPsiMethod.getReturnType();
+    if (!isAssert()) {
+      if (returnType == null)
+        throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " has a null return type PsiType.");
+
+      if (returnType != PsiType.BOOLEAN && !returnType.getCanonicalText().equals(Boolean.class.toString())) {
+        throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " must have a null return type PsiType of boolean or Boolean.");
+      }
+    }
+
+    boolean parameterFound = false;
+    for (int i = 0; i < myPsiMethod.getParameterList().getParameters().length; i++) {
+      if (myPsiParameter.equals(myPsiMethod.getParameterList().getParameters()[i])) {
+        parameterFound = true;
+        break;
+      }
+    }
+
+    if (!parameterFound) {
+      throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " must have parameter " + getFullyQualifiedName(myPsiParameter));
+    }
+  }
+
+  private boolean isAssert() {
+    return myType == ASSERT_IS_NULL_METHOD || myType == ASSERT_IS_NOT_NULL_METHOD || myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD;
+  }
+
+  private String initClassNameFromPsiMethod() {
+    PsiElement psiElement = myPsiMethod.getContainingClass();
+    PsiClass psiClass = (PsiClass) psiElement;
+    return psiClass.getQualifiedName();
+  }
+
+  private String initMethodNameFromPsiMethod() {
+    return myPsiMethod.getName();
+  }
+
+  private List<String> initParameterNamesFromPsiMethod(PsiParameter selectedParameter) {
+    List<String> parameters = new ArrayList<String>();
+    for (int i = 0; i < myPsiMethod.getParameterList().getParameters().length; i++) {
+      PsiParameter param = myPsiMethod.getParameterList().getParameters()[i];
+      String parameter = getFullyQualifiedName(param);
+      if (param.equals(selectedParameter))
+        parameters.add("*" + parameter + "*");
+      else
+        parameters.add(parameter);
+    }
+    return parameters;
+  }
+
+  public static String getFullyQualifiedName(PsiParameter psiParameter) {
+    PsiTypeElement typeElement = psiParameter.getTypeElement();
+    if (typeElement == null)
+      throw new RuntimeException("Parameter has null typeElement " + psiParameter.getName());
+
+    PsiType psiType = typeElement.getType();
+
+    return psiType.getCanonicalText() + " " + psiParameter.getName();
+  }
+
+  private String initFullName(String className, String methodName, List<String> parameters) {
+    String s = className + "." + methodName + "(";
+    for (String parameterName : parameters) {
+      s += parameterName + ", ";
+    }
+    s = s.substring(0, s.length() - 2);
+    s += ")";
+    return s;
+  }
+
+  private String initShortName(String methodName, List<String> parameterNames) {
+    String shortName = methodName + "(";
+    for (String parameterName : parameterNames) {
+      if (parameterNames.lastIndexOf(".") > -1)
+        shortName += parameterName.substring(parameterName.lastIndexOf(".") + 1) + ", ";
+      else
+        shortName += parameterName + ", ";
+    }
+    shortName = shortName.substring(0, shortName.lastIndexOf(", "));
+    shortName += ")";
+    return shortName;
+  }
+
+  @NotNull
+  public PsiMethod getPsiMethod() {
+    return myPsiMethod;
+  }
+
+  public String getShortName() {
+    return shortName;
+  }
+
+  @NotNull
+  public PsiParameter getPsiParameter() {
+    return myPsiParameter;
+  }
+
+
+  @Override
+  public int compareTo(MethodConditionCheck o) {
+    return fullName.compareToIgnoreCase(fullName);
+  }
+
+  @Override
+  public String toString() {
+    return fullName;
+  }
+
+  static class Builder {
+    private final @NotNull String serializedRepresentation;
+    private final @NotNull Project project;
+    private final @NotNull Type type;
+
+
+    Builder(@NotNull String serializedRepresentation, @NotNull Type type, @NotNull Project project) {
+      this.serializedRepresentation = serializedRepresentation;
+      this.project = project;
+      this.type = type;
+    }
+
+    private MethodConditionCheck validateFullyQualifiedClassMethodAndParameterNameAndGetPsiMethod(String fullyQualifiedClassMethodAndParameterName) {
+      String classNameAndMethodName = parseClassNameAndMethodName(fullyQualifiedClassMethodAndParameterName);
+
+      String className = classNameAndMethodName.substring(0, classNameAndMethodName.lastIndexOf("."));
+      String methodName = classNameAndMethodName.substring(classNameAndMethodName.lastIndexOf(".") + 1);
+
+      String allParametersSubString = fullyQualifiedClassMethodAndParameterName.substring(fullyQualifiedClassMethodAndParameterName.indexOf("(") + 1, fullyQualifiedClassMethodAndParameterName.lastIndexOf(")")).trim();
+      if (allParametersSubString.isEmpty()) {
+        throw new IllegalArgumentException("Name should contain 1+ parameter (between opening and closing parenthesis).  " + fullyQualifiedClassMethodAndParameterName);
+      } else if (allParametersSubString.contains("*") && allParametersSubString.indexOf("*") == allParametersSubString.lastIndexOf("*")) {
+        throw new IllegalArgumentException("Selected Parameter should be surrounded by asterisks.  " + fullyQualifiedClassMethodAndParameterName);
+      }
+
+      String parameterClassAndName = allParametersSubString.substring(allParametersSubString.indexOf("*") + 1, allParametersSubString.lastIndexOf("*")).trim();
+
+      PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(className, GlobalSearchScope.allScope(project));
+      if (psiClass == null) {
+        throw new IllegalArgumentException("Unable to locate class " + className + " which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
+      }
+
+      List<PsiMethod> psiMethods = findPsiMethodsInPsiClassWithMatchingMethodName(psiClass, methodName);
+      if (psiMethods.size() == 0) {
+        throw new IllegalArgumentException("Unable to locate method in class " + className + " named " + methodName + ", which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
+      }
+
+      PsiMethod psiMethod = findPsiMethodWithMatchingParameters(psiMethods, allParametersSubString);
+      if (psiMethod == null) {
+        throw new IllegalArgumentException("Unable to locate method in class " + className + " named " + methodName + " with a parameter named " + parameterClassAndName + " which was parsed from full name " + fullyQualifiedClassMethodAndParameterName + ".  The following methods matched on method name but not parameter name " + psiMethods);
+      }
+
+      PsiParameter psiParameter = null;
+      for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
+        PsiParameter parameter = psiMethod.getParameterList().getParameters()[i];
+        if (parameterClassAndName.equals(getFullyQualifiedName(parameter))) {
+          psiParameter = parameter;
+          break;
+        }
+      }
+
+      if (psiParameter == null) {
+        throw new IllegalArgumentException("Unable to locate parameter " + parameterClassAndName + " in class " + className + " named " + methodName + ", which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
+      }
+
+      return new MethodConditionCheck(psiMethod, psiParameter, type);
+    }
+
+    private String parseClassNameAndMethodName(String fullyQualifiedClassMethodAndParameterName) {
+      if (!fullyQualifiedClassMethodAndParameterName.contains("(")) {
+        throw new IllegalArgumentException("Name should contain a opening parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
+      } else if (!fullyQualifiedClassMethodAndParameterName.contains(")")) {
+        throw new IllegalArgumentException("Name should contain a closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
+      } else if (fullyQualifiedClassMethodAndParameterName.indexOf("(", fullyQualifiedClassMethodAndParameterName.indexOf("(") + 1) > -1) {
+        throw new IllegalArgumentException("Name should only contain one opening parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
+      } else if (fullyQualifiedClassMethodAndParameterName.indexOf(")", fullyQualifiedClassMethodAndParameterName.indexOf(")") + 1) > -1) {
+        throw new IllegalArgumentException("Name should only contain one closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
+      } else if (fullyQualifiedClassMethodAndParameterName.indexOf(")") < fullyQualifiedClassMethodAndParameterName.indexOf("(")) {
+        throw new IllegalArgumentException("Opening parenthesis should precede closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
+      }
+
+      String classNameAndMethodName = fullyQualifiedClassMethodAndParameterName.substring(0, fullyQualifiedClassMethodAndParameterName.indexOf("("));
+      if (!classNameAndMethodName.contains(".")) {
+        throw new IllegalArgumentException("Name should contain a dot between the class name and method name (before the opening parenthesis).  " + fullyQualifiedClassMethodAndParameterName);
+      }
+      return classNameAndMethodName;
+    }
+
+    private PsiMethod findPsiMethodWithMatchingParameters(List<PsiMethod> psiMethods, String allParametersSubString) {
+      String[] parameterClassAndNameArray = allParametersSubString.split(",");
+      List<String> parameterClassToMatch = new ArrayList<String>();
+      for (String parameterClassAndName : parameterClassAndNameArray) {
+        parameterClassAndName = parameterClassAndName.replace("*", "").trim();
+        parameterClassAndName = parameterClassAndName.substring(0, parameterClassAndName.indexOf(" ")).trim();
+        parameterClassToMatch.add(parameterClassAndName);
+      }
+
+      for (PsiMethod method : psiMethods) {
+        List<String> parameterForCurrentMethod = new ArrayList<String>();
+        for (int i = 0; i < method.getParameterList().getParameters().length; i++) {
+          PsiParameter psiParameter = method.getParameterList().getParameters()[i];
+          PsiTypeElement typeElement = psiParameter.getTypeElement();
+          if (typeElement == null)
+            break;
+
+          PsiType psiType = typeElement.getType();
+          parameterForCurrentMethod.add(psiType.getCanonicalText().trim());
+        }
+
+        if (parameterForCurrentMethod.equals(parameterClassToMatch))
+          return method;
+      }
+
+      return null;
+    }
+
+    private List<PsiMethod> findPsiMethodsInPsiClassWithMatchingMethodName(PsiClass psiClass, String methodName) {
+      List<PsiMethod> psiMethods = new ArrayList<PsiMethod>();
+      for (int i = 0; i < psiClass.getMethods().length; i++) {
+        PsiMethod possibleMatchPsiMethod = psiClass.getMethods()[i];
+        if (methodName.equals(possibleMatchPsiMethod.getName())) {
+          psiMethods.add(possibleMatchPsiMethod);
+        }
+      }
+      return psiMethods;
+    }
+
+    public MethodConditionCheck build() {
+      return validateFullyQualifiedClassMethodAndParameterNameAndGetPsiMethod(serializedRepresentation);
+    }
+  }
+}
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
new file mode 100644
index 000000000000..d48698d2dfa4
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
@@ -0,0 +1,264 @@
+/*
+ * 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.codeInspection.dataFlow;
+
+import com.intellij.codeInsight.*;
+import com.intellij.codeInspection.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.ui.*;
+import com.intellij.ui.components.*;
+import org.jetbrains.annotations.*;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.util.List;
+
+/**
+ * Dialog that appears when user clicks the "Configure IsNull/IsNotNull/True/False Check/Assertion Methods"
+ * on the Errors dialog for the Constant Conditions Inspection.  It is divided into 6 parts
+ * <ol>
+ *   <li>Is Null Check MethodsPanel</li>
+ *   <li>Is Not Null Check MethodsPanel</li>
+ *   <li>Assert Is Null MethodsPanel</li>
+ *   <li>Assert Is Not Null MethodsPanel</li>
+ *   <li>Assert True MethodsPanel</li>
+ *   <li>Assert False MethodsPanel</li>
+ * </ol>
+ *
+ * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
+ *         Creation Date: 8/3/12
+ */
+public class ConditionCheckDialog extends DialogWrapper {
+  private final Project myProject;
+  private final @NotNull Splitter mainSplitter;
+  private final @NotNull MethodsPanel myIsNullCheckMethodPanel;
+  private final @NotNull MethodsPanel myIsNotNullCheckMethodPanel;
+  private final @NotNull MethodsPanel myAssertIsNullMethodPanel;
+  private final @NotNull MethodsPanel myAssertIsNotNullMethodPanel;
+  private final @NotNull MethodsPanel myAssertTrueMethodPanel;
+  private final @NotNull MethodsPanel myAssertFalseMethodPanel;
+
+  public ConditionCheckDialog(Project project, String mainDialogTitle) {
+    super(project, true);
+    myProject = project;
+
+    final ConditionCheckManager manager = ConditionCheckManager.getInstance(myProject);
+    mainSplitter = new Splitter(true, 0.3f);
+    final Splitter topThirdSplitter = new Splitter(false);
+    final Splitter bottomTwoThirdsSplitter = new Splitter(true);
+    final Splitter isNullIsNotNullCheckMethodSplitter = new Splitter(false);
+    final Splitter assertTrueFalseMethodSplitter = new Splitter(false);
+
+    List<MethodConditionCheck> isNullCheckMethods = new ArrayList<MethodConditionCheck>(manager.getIsNullCheckMethods());
+    List<MethodConditionCheck> isNotNullCheckMethods = new ArrayList<MethodConditionCheck>(manager.getIsNotNullCheckMethods());
+    List<MethodConditionCheck> assertIsNullMethods = new ArrayList<MethodConditionCheck>(manager.getAssertIsNullMethods());
+    List<MethodConditionCheck> assertIsNotNullMethods = new ArrayList<MethodConditionCheck>(manager.getAssertIsNotNullMethods());
+    List<MethodConditionCheck> assertTrueMethods = new ArrayList<MethodConditionCheck>(manager.getAssertTrueMethods());
+    List<MethodConditionCheck> assertFalseMethods = new ArrayList<MethodConditionCheck>(manager.getAssertFalseMethods());
+
+    myAssertIsNullMethodPanel = new MethodsPanel(assertIsNullMethods, ConditionChecker.Type.ASSERT_IS_NULL_METHOD, myProject);
+    myAssertIsNotNullMethodPanel = new MethodsPanel(assertIsNotNullMethods, ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD, myProject);
+    myIsNullCheckMethodPanel = new MethodsPanel(isNullCheckMethods, ConditionChecker.Type.IS_NULL_METHOD, myProject);
+    myIsNotNullCheckMethodPanel = new MethodsPanel(isNotNullCheckMethods, ConditionChecker.Type.IS_NOT_NULL_METHOD, myProject);
+    myAssertTrueMethodPanel = new MethodsPanel(assertTrueMethods, ConditionChecker.Type.ASSERT_TRUE_METHOD, myProject);
+    myAssertFalseMethodPanel = new MethodsPanel(assertFalseMethods, ConditionChecker.Type.ASSERT_FALSE_METHOD, myProject);
+
+    isNullIsNotNullCheckMethodSplitter.setFirstComponent(myIsNullCheckMethodPanel.getComponent());
+    isNullIsNotNullCheckMethodSplitter.setSecondComponent(myIsNotNullCheckMethodPanel.getComponent());
+    assertTrueFalseMethodSplitter.setFirstComponent(myAssertTrueMethodPanel.getComponent());
+    assertTrueFalseMethodSplitter.setSecondComponent(myAssertFalseMethodPanel.getComponent());
+
+    topThirdSplitter.setFirstComponent(myAssertIsNullMethodPanel.getComponent());
+    topThirdSplitter.setSecondComponent(myAssertIsNotNullMethodPanel.getComponent());
+    bottomTwoThirdsSplitter.setFirstComponent(isNullIsNotNullCheckMethodSplitter);
+    bottomTwoThirdsSplitter.setSecondComponent(assertTrueFalseMethodSplitter);
+
+    mainSplitter.setFirstComponent(topThirdSplitter);
+    mainSplitter.setSecondComponent(bottomTwoThirdsSplitter);
+
+    topThirdSplitter.setPreferredSize(new Dimension(600, 400));
+    bottomTwoThirdsSplitter.setPreferredSize(new Dimension(600, 800));
+
+    myAssertIsNullMethodPanel.setOtherMethodsPanels(myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
+    myAssertIsNotNullMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
+    myIsNullCheckMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
+    myIsNotNullCheckMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
+    myAssertTrueMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel, myAssertFalseMethodPanel);
+    myAssertFalseMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel, myAssertTrueMethodPanel);
+
+    init();
+    setTitle(mainDialogTitle);
+  }
+
+  @Override
+  protected JComponent createCenterPanel() {
+    return mainSplitter;
+  }
+
+  @Override
+  protected void doOKAction() {
+    final ConditionCheckManager manager = ConditionCheckManager.getInstance(myProject);
+    manager.setIsNotNullCheckMethods(myIsNotNullCheckMethodPanel.getMethodConditionChecker());
+    manager.setIsNullCheckMethods(myIsNullCheckMethodPanel.getMethodConditionChecker());
+    manager.setAssertNotNullMethods(myAssertIsNotNullMethodPanel.getMethodConditionChecker());
+    manager.setAssertNullMethods(myAssertIsNullMethodPanel.getMethodConditionChecker());
+    manager.setAssertTrueMethods(myAssertTrueMethodPanel.getMethodConditionChecker());
+    manager.setAssertFalseMethods(myAssertFalseMethodPanel.getMethodConditionChecker());
+
+    super.doOKAction();
+  }
+
+  /**
+   * Is Null, Is Not Null, Assert True and Assert False Method Panel at the top of the main Dialog.
+   */
+  class MethodsPanel {
+    private final @NotNull JBList myList;
+    private final @NotNull JPanel myPanel;
+    private final @NotNull Project myProject;
+    private Set<MethodsPanel> otherPanels;
+
+    public MethodsPanel(final List<MethodConditionCheck> checkers, final ConditionChecker.Type type, final Project myProject) {
+      this.myProject = myProject;
+      myList = new JBList(new CollectionListModel<MethodConditionCheck>(checkers));
+      myPanel = new JPanel(new BorderLayout());
+      myPanel.setBorder(IdeBorderFactory.createTitledBorder(initTitle(type), false, new Insets(10, 0, 0, 0)));
+      myPanel.setPreferredSize(new Dimension(500, 500));
+
+      myList.setCellRenderer(new ColoredListCellRenderer() {
+        @Override
+        protected void customizeCellRenderer(JList list, Object value, int index, boolean selected, boolean hasFocus) {
+          String s = value.toString();
+          if (s.contains("*")) {
+            int indexOfAsterix1 = s.indexOf("*");
+            int indexOfAsterix2 = s.lastIndexOf("*");
+            if (indexOfAsterix1 >= 0 && indexOfAsterix1 < s.length() && indexOfAsterix2 >= 0 && indexOfAsterix2 < s.length() && indexOfAsterix1 < indexOfAsterix2) {
+              append(s.substring(0, indexOfAsterix1), SimpleTextAttributes.REGULAR_ATTRIBUTES);
+              append(s.substring(indexOfAsterix1 + 1, indexOfAsterix2), SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES);
+              append(s.substring(indexOfAsterix2 + 1), SimpleTextAttributes.REGULAR_ATTRIBUTES);
+            } else {
+              append(s, SimpleTextAttributes.REGULAR_ATTRIBUTES);
+            }
+          }
+        }
+      });
+
+      final ToolbarDecorator toolbarDecorator = ToolbarDecorator.createDecorator(myList).disableUpDownActions()
+        .setAddAction(new AnActionButtonRunnable() {
+          @Override
+          public void run(AnActionButton anActionButton) {
+            chooseMethod(null, type, myList.getModel().getSize());
+          }
+        })
+        .setRemoveAction(new AnActionButtonRunnable() {
+          @Override
+          public void run(AnActionButton anActionButton) {
+            CollectionListModel model = getCollectionListModel();
+            if (myList.getSelectedIndex() >= 0 && myList.getSelectedIndex() < model.getSize()) {
+              model.remove(myList.getSelectedIndex());
+            }
+          }
+        });
+
+      myList.addMouseListener(
+        new MouseAdapter() {
+          public void mouseClicked(MouseEvent e) {
+            if (e.getClickCount() == 2) {
+              int index = myList.locationToIndex(e.getPoint());
+              CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
+              if (index >= 0 && model.getSize() > index) {
+                chooseMethod(model.getElementAt(index), type, index);
+              }
+            }
+          }
+        }
+      );
+      final JPanel panel = toolbarDecorator.createPanel();
+      myPanel.add(panel);
+      myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    }
+
+    private String initTitle(@NotNull ConditionChecker.Type type) {
+      if (type.equals(ConditionChecker.Type.IS_NULL_METHOD))
+        return InspectionsBundle.message("configure.checker.option.isNull.method.panel.title");
+      else if (type.equals(ConditionChecker.Type.IS_NOT_NULL_METHOD))
+        return InspectionsBundle.message("configure.checker.option.isNotNull.method.panel.title");
+      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NULL_METHOD))
+        return InspectionsBundle.message("configure.checker.option.assert.isNull.method.panel.title");
+      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD))
+        return InspectionsBundle.message("configure.checker.option.assert.isNotNull.method.panel.title");
+      else if (type.equals(ConditionChecker.Type.ASSERT_TRUE_METHOD))
+        return InspectionsBundle.message("configure.checker.option.assert.true.method.panel.title");
+      else if (type.equals(ConditionChecker.Type.ASSERT_FALSE_METHOD))
+        return InspectionsBundle.message("configure.checker.option.assert.false.method.panel.title");
+      else
+        throw new IllegalArgumentException("MethodCheckerDetailsDialog does not support type " + type);
+    }
+
+    private void chooseMethod(@Nullable MethodConditionCheck checker, ConditionChecker.Type type, int index) {
+      MethodCheckerDetailsDialog pickMethodPanel = new MethodCheckerDetailsDialog(checker, type, myProject, myPanel, getConditionCheckers(), getOtherCheckers());
+      pickMethodPanel.show();
+      MethodConditionCheck chk = pickMethodPanel.getMethodConditionChecker();
+      if (chk != null) {
+        CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
+        if (model.getSize() <= index)
+          model.add(chk);
+        else
+          model.setElementAt(chk, index);
+      }
+    }
+
+    private CollectionListModel<MethodConditionCheck> getCollectionListModel() {
+      //noinspection unchecked
+      return (CollectionListModel<MethodConditionCheck>) myList.getModel();
+    }
+
+    @NotNull
+    public JPanel getComponent() {
+      return myPanel;
+    }
+
+    public List<MethodConditionCheck> getMethodConditionChecker() {
+      CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
+      return new ArrayList<MethodConditionCheck>(model.getItems());
+    }
+
+    public Set<ConditionChecker> getConditionCheckers() {
+      Set<ConditionChecker> set = new HashSet<ConditionChecker>();
+      set.addAll(getMethodConditionChecker());
+      return set;
+    }
+
+    public void setOtherMethodsPanels(MethodsPanel p1, MethodsPanel p2, MethodsPanel p3, MethodsPanel p4, MethodsPanel p5) {
+      otherPanels = new HashSet<MethodsPanel>();
+      otherPanels.add(p1);
+      otherPanels.add(p2);
+      otherPanels.add(p3);
+      otherPanels.add(p4);
+      otherPanels.add(p5);
+    }
+
+    public Set<ConditionChecker> getOtherCheckers() {
+      Set<ConditionChecker> otherCheckers = new HashSet<ConditionChecker>();
+      for (MethodsPanel otherPanel : otherPanels) {
+        otherCheckers.addAll(otherPanel.getConditionCheckers());
+      }
+      return otherCheckers;
+    }
+  }
+}
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
index e3170217680f..2ec949a983bd 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.codeInspection.dataFlow;
 
+import com.intellij.codeInsight.ConditionCheckManager;
 import com.intellij.codeInsight.ExceptionUtil;
 import com.intellij.codeInspection.dataFlow.instructions.*;
 import com.intellij.codeInspection.dataFlow.value.*;
@@ -1342,6 +1343,82 @@ class ControlFlowAnalyzer extends JavaElementVisitor {
         }
       }
 
+      if (ConditionCheckManager.isCheck(resolved)) {
+        if (ConditionCheckManager.isAssertIsNullCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isAssertIsNullCheckMethod(resolved, paramIndex++)) {
+              addInstruction(new PushInstruction(myFactory.getConstFactory().getNull(), null));
+              addInstruction(new BinopInstruction(JavaTokenType.EQEQ, null, expression.getProject()));
+              conditionalExit(exitPoint, false);  // Exit if Equal NULL is True
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        } else if (ConditionCheckManager.isAssertIsNotNullCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isAssertIsNotNullCheckMethod(resolved, paramIndex++)) {
+              addInstruction(new PushInstruction(myFactory.getConstFactory().getNull(), null));
+              addInstruction(new BinopInstruction(JavaTokenType.EQEQ, null, expression.getProject()));
+              conditionalExit(exitPoint, true); // Exit if NotEqual NULL is True
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        } else if (ConditionCheckManager.isNullCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isNullCheckMethod(resolved, paramIndex++)) {
+              addInstruction(new PushInstruction(myFactory.getConstFactory().getNull(), null));
+              addInstruction(new BinopInstruction(JavaTokenType.EQEQ, null, expression.getProject()));
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        } else if (ConditionCheckManager.isNotNullCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isNotNullCheckMethod(resolved, paramIndex++)) {
+              addInstruction(new PushInstruction(myFactory.getConstFactory().getNull(), null));
+              addInstruction(new BinopInstruction(JavaTokenType.NE, null, expression.getProject()));
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        } else if (ConditionCheckManager.isAssertTrueCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isAssertTrueCheckMethod(resolved, paramIndex++)) {
+              conditionalExit(exitPoint, false);
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        } else if (ConditionCheckManager.isAssertFalseCheckMethod(resolved)) {
+          int paramIndex = 0;
+          for (PsiExpression param : params) {
+            param.accept(this);
+            if (ConditionCheckManager.isAssertFalseCheckMethod(resolved, paramIndex++)) {
+              conditionalExit(exitPoint, true);
+            } else {
+              addInstruction(new PopInstruction());
+            }
+          }
+          return true;
+        }
+      }
+
       // Idea project only.
       if (qualifierExpression != null) {
         if (qualifierExpression.textMatches("LOG")) {
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java
index 56b1d22041f4..2b7bd60bae48 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspection.java
@@ -587,6 +587,24 @@ public class DataFlowInspection extends BaseLocalInspectionTool {
       gc.insets.bottom = 15;
       add(configureAnnotations, gc);
 
+      final JButton configureCheckAnnotations = new JButton(InspectionsBundle.message("configure.checker.option.button"));
+      configureCheckAnnotations.addActionListener(new ActionListener() {
+        @Override
+        public void actionPerformed(ActionEvent e) {
+          Project project = PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(OptionsPanel.this));
+          if (project == null) project = ProjectManager.getInstance().getDefaultProject();
+          final ConditionCheckDialog dialog = new ConditionCheckDialog(project,
+                                                                       InspectionsBundle.message("configure.checker.option.main.dialog.title")
+          );
+          dialog.show();
+        }
+      });
+      gc.gridy++;
+      gc.fill = GridBagConstraints.NONE;
+      gc.insets.left = 20;
+      gc.insets.bottom = 15;
+      add(configureCheckAnnotations, gc);
+
       gc.fill = GridBagConstraints.HORIZONTAL;
       gc.weighty = 1;
       gc.insets.left = 0;
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
new file mode 100644
index 000000000000..cd261e1c9214
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
@@ -0,0 +1,621 @@
+/*
+ * 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.codeInspection.dataFlow;
+
+import com.intellij.codeInsight.*;
+import com.intellij.codeInspection.*;
+import com.intellij.ide.util.*;
+import com.intellij.openapi.editor.event.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.psi.*;
+import com.intellij.psi.search.*;
+import com.intellij.ui.*;
+import org.jetbrains.annotations.*;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.beans.*;
+import java.util.*;
+import java.util.List;
+
+import static com.intellij.codeInsight.ConditionChecker.Type.*;
+
+/**
+ * Dialog that appears when the user clicks the Add Button or double clicks a row item in a MethodsPanel.  The MethodsPanel is accessed from the ConditionCheckDialog
+ */
+class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChangeListener, ItemListener {
+  private final @NotNull ConditionChecker.Type myType;
+  private final @NotNull Project myProject;
+  private final @NotNull ParameterDropDown parameterDropDown;
+  private final @NotNull MethodDropDown methodDropDown;
+  private final @NotNull ClassField classField;
+  private final @NotNull Set<ConditionChecker> myOtherCheckers;
+  private final @Nullable MethodConditionCheck myPreviouslySelectedChecker;
+
+  /**
+   * Set by the OK and/or Cancel actions so that the caller can retrieve it via a call to getMethodIsNullIsNotNullChecker
+   */
+  private @Nullable MethodConditionCheck mySelectedChecker;
+
+  MethodCheckerDetailsDialog(@Nullable MethodConditionCheck previouslySelectedChecker, @NotNull ConditionChecker.Type type, @NotNull Project project, @NotNull Component component, @NotNull Set<ConditionChecker> otherCheckersSameType, @NotNull Set<ConditionChecker> otherCheckers) {
+    super(component, true);
+    if (!isSupported(type))
+      throw new IllegalArgumentException("Type is invalid " + type);
+
+    myProject = project;
+    myType = type;
+    myOtherCheckers = new HashSet<ConditionChecker>(otherCheckersSameType);
+    myOtherCheckers.addAll(otherCheckers);
+    myPreviouslySelectedChecker = previouslySelectedChecker;
+    if (myPreviouslySelectedChecker != null)
+      myOtherCheckers.remove(myPreviouslySelectedChecker);
+
+    PsiClass psiClass = null;
+    PsiMethod psiMethod = null;
+    PsiParameter psiParameter = null;
+    if (previouslySelectedChecker != null) {
+      psiMethod = previouslySelectedChecker.getPsiMethod();
+      psiClass = psiMethod.getContainingClass();
+      psiParameter = previouslySelectedChecker.getPsiParameter();
+    }
+
+    classField = new ClassField(myProject, psiClass);
+    methodDropDown = new MethodDropDown(psiClass, psiMethod, myType, MethodDropDown.buildModel());
+    parameterDropDown = new ParameterDropDown(psiMethod, psiParameter, ParameterDropDown.buildModel(), myType);
+    classField.addPropertyChangeListener(methodDropDown);
+    classField.addPropertyChangeListener(parameterDropDown);
+    classField.addPropertyChangeListener(this);
+    methodDropDown.addItemListener(parameterDropDown);
+    methodDropDown.addItemListener(this);
+    parameterDropDown.addItemListener(this);
+    init();
+    checkOkActionEnable();
+    setTitle(initTitle(type));
+  }
+
+  private static boolean isSupported(ConditionChecker.Type type) {
+    return type == IS_NULL_METHOD || type == IS_NOT_NULL_METHOD ||
+           type == ASSERT_IS_NULL_METHOD || type == ASSERT_IS_NOT_NULL_METHOD ||
+           type == ASSERT_TRUE_METHOD || type == ASSERT_FALSE_METHOD;
+  }
+
+  private String initTitle(@NotNull ConditionChecker.Type type) {
+    if (type.equals(IS_NULL_METHOD))
+      return InspectionsBundle.message("configure.checker.option.isNull.add.method.checker.dialog.title");
+    else if (type.equals(IS_NOT_NULL_METHOD))
+      return InspectionsBundle.message("configure.checker.option.isNotNull.add.method.checker.dialog.title");
+    else if (type.equals(ASSERT_IS_NULL_METHOD))
+      return InspectionsBundle.message("configure.checker.option.assert.isNull.add.method.checker.dialog.title");
+    else if (type.equals(ASSERT_IS_NOT_NULL_METHOD))
+      return InspectionsBundle.message("configure.checker.option.assert.isNotNull.add.method.checker.dialog.title");
+    else if (type.equals(ASSERT_TRUE_METHOD))
+      return InspectionsBundle.message("configure.checker.option.assert.true.add.method.checker.dialog.title");
+    else if (type.equals(ASSERT_FALSE_METHOD))
+      return InspectionsBundle.message("configure.checker.option.assert.false.add.method.checker.dialog.title");
+    else
+      throw new IllegalArgumentException("MethodCheckerDetailsDialog does not support type " + type);
+  }
+
+  @Override
+  protected JComponent createCenterPanel() {
+    final JPanel panel = new JPanel();
+    panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
+
+    final LabeledComponent<ClassField> classComponent = new LabeledComponent<ClassField>();
+    final LabeledComponent<MethodDropDown> methodComponent = new LabeledComponent<MethodDropDown>();
+    final LabeledComponent<ParameterDropDown> parameterComponent = new LabeledComponent<ParameterDropDown>();
+
+    classComponent.setText("Class");
+    methodComponent.setText("Method");
+    parameterComponent.setText("Parameter");
+
+    classComponent.setComponent(classField);
+    methodComponent.setComponent(methodDropDown);
+    parameterComponent.setComponent(parameterDropDown);
+
+    panel.add(classComponent);
+    panel.add(methodComponent);
+    panel.add(parameterComponent);
+
+    return panel;
+  }
+
+  MethodConditionCheck getMethodConditionChecker() {
+    return mySelectedChecker;
+  }
+
+  private MethodConditionCheck buildMethodConditionChecker() {
+    PsiClass psiClass = classField.getPsiClass();
+    PsiMethod psiMethod = methodDropDown.getSelectedPsiMethod();
+    PsiParameter psiParameter = parameterDropDown.getSelectedPsiParameter();
+    if (psiClass != null && psiMethod != null && psiParameter != null) {
+      return new MethodConditionCheck(psiMethod, psiParameter, myType);
+    } else {
+      return null;
+    }
+  }
+
+  private boolean overlaps() {
+    MethodConditionCheck thisChecker = buildMethodConditionChecker();
+    for (ConditionChecker overlappingChecker : myOtherCheckers) {
+      if (thisChecker.overlaps(overlappingChecker)) {
+        Messages.showMessageDialog(myProject,
+                                   InspectionsBundle.message("configure.checker.option.overlap.error.msg") + " " + overlappingChecker.toString(),
+                                   InspectionsBundle.message("configure.checker.option.overlap.error.title"),
+                                   Messages.getErrorIcon());
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public void propertyChange(PropertyChangeEvent evt) {
+//    if (evt.getPropertyName().equals(ClassField.PROPERTY_PSICLASS)) {
+    checkOkActionEnable();
+//    }
+  }
+
+  @Override
+  public void itemStateChanged(ItemEvent e) {
+    checkOkActionEnable();
+  }
+
+  private void checkOkActionEnable() {
+    if (classField.getPsiClass() == null || methodDropDown.getSelectedPsiMethod() == null || parameterDropDown.getSelectedPsiParameter() == null) {
+      setOKActionEnabled(false);
+    } else {
+      setOKActionEnabled(true);
+    }
+  }
+
+  @Override
+  protected void doOKAction() {
+    if (!overlaps()) {
+      MethodConditionCheck checker = buildMethodConditionChecker();
+      if (checker != null) {
+        if (checker.equals(myPreviouslySelectedChecker)) {
+          mySelectedChecker = myPreviouslySelectedChecker;
+        } else {
+          mySelectedChecker = checker;
+        }
+      }
+      super.doOKAction();
+    }
+  }
+
+  public boolean isOKActionEnabled() {
+    if (!myOKAction.isEnabled()) return false;
+    PsiClass psiClass = classField.getPsiClass();
+    PsiMethod psiMethod = methodDropDown.getSelectedPsiMethod();
+    PsiParameter psiParameter = parameterDropDown.getSelectedPsiParameter();
+    if (psiClass == null || psiMethod == null || psiParameter == null)
+      return false;
+    else
+      return true;
+  }
+
+  /**
+   * Input Text Field for Class Name
+   */
+  static class ClassField extends EditorTextFieldWithBrowseButton implements ActionListener, DocumentListener {
+    private final @NotNull Project myProject;
+    private @Nullable PsiClass myPsiClass;
+    public static final String PROPERTY_PSICLASS = "ClassField.myPsiClass";
+
+    public ClassField(@NotNull Project project, @Nullable PsiClass psiClass) {
+      super(project, true, buildVisibilityChecker());
+      myProject = project;
+      myPsiClass = psiClass;
+      setPreferredSize(new Dimension(500, (int) getPreferredSize().getHeight()));
+      if (myPsiClass != null)
+        setText(myPsiClass.getQualifiedName());
+      addActionListener(this);
+      getChildComponent().addDocumentListener(this);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+      final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject)
+        .createNoInnerClassesScopeChooser("Choose Class", new EverythingGlobalScope(myProject), new ClassFilter() {
+          @Override
+          public boolean isAccepted(PsiClass aClass) {
+            return !aClass.isAnnotationType();
+          }
+        }, null);
+      chooser.showDialog();
+      PsiClass psiClass = chooser.getSelected();
+      if (psiClass != null)
+        setText(chooser.getSelected().getQualifiedName());
+    }
+
+    @Nullable
+    public PsiClass getPsiClass() {
+      return myPsiClass;
+    }
+
+    @Override
+    public void beforeDocumentChange(DocumentEvent event) {
+    }
+
+    @Override
+    public void documentChanged(DocumentEvent event) {
+      String className = event.getDocument().getText();
+      PsiClass psiClass = null;
+      if (className != null) {
+        psiClass = JavaPsiFacade.getInstance(myProject).findClass(className, new EverythingGlobalScope(myProject));
+      }
+
+      if (psiClass != null && myPsiClass != null) {
+        if (!psiClass.equals(myPsiClass)) {
+          firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
+          myPsiClass = psiClass;
+        }
+      } else if (psiClass != null) {
+        firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
+        myPsiClass = psiClass;
+      } else if (myPsiClass != null) {
+        firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
+        myPsiClass = null;
+      }
+    }
+
+    private static JavaCodeFragment.VisibilityChecker buildVisibilityChecker() {
+      return new JavaCodeFragment.VisibilityChecker() {
+        @Override
+        public Visibility isDeclarationVisible(PsiElement declaration, PsiElement place) {
+          return Visibility.VISIBLE;
+        }
+      };
+    }
+  }
+
+  /**
+   * Drop Down for picking Method Name
+   */
+  static class MethodDropDown extends JComboBox implements PropertyChangeListener {
+    private @Nullable PsiClass myPsiClass;
+    private final @NotNull ConditionChecker.Type myType;
+    private final @NotNull SortedComboBoxModel<MethodWrapper> myModel;
+
+    MethodDropDown(@Nullable PsiClass psiClass, @Nullable PsiMethod psiMethod, @NotNull ConditionChecker.Type type, SortedComboBoxModel<MethodWrapper> model) {
+      super(model);
+
+      if (!isSupported(type))
+        throw new IllegalArgumentException("Type is invalid " + type);
+
+      myPsiClass = psiClass;
+      myType = type;
+      myModel = model;
+      setEnabled(myPsiClass != null);
+      initValues();
+      if (psiMethod != null) {
+        for (Iterator<MethodWrapper> iterator = myModel.iterator(); iterator.hasNext(); ) {
+          MethodWrapper methodWrapper = iterator.next();
+          if (methodWrapper.getPsiMethod().equals(psiMethod)) {
+            setSelectedItem(methodWrapper);
+          }
+        }
+      }
+    }
+
+    private void initValues() {
+      if (myPsiClass != null) {
+        myModel.clear();
+        myModel.setSelectedItem(null);
+        PsiMethod[] allMethods = myPsiClass.getAllMethods();
+        for (PsiMethod allMethod : allMethods) {
+          if (qualifies(allMethod))
+            myModel.add(new MethodWrapper(allMethod));
+        }
+      }
+    }
+
+    public boolean qualifies(PsiMethod psiMethod) {
+      if (isMethodFromJavaLangObject(psiMethod)) {
+        return false;
+      }
+
+      final PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      if (parameters.length < 1) {
+        return false;
+      }
+
+      if (myType == IS_NULL_METHOD || myType == IS_NOT_NULL_METHOD) {
+        PsiType returnType = psiMethod.getReturnType();
+        if (returnType != PsiType.BOOLEAN && (returnType == null || !returnType.getCanonicalText().equals(Boolean.class.toString()))) {
+          return false;
+        }
+      } else if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
+        boolean booleanParamExists = false;
+        for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
+          PsiParameter psiParameter = psiMethod.getParameterList().getParameters()[i];
+          PsiType type = psiParameter.getType();
+          if (type.equals(PsiType.BOOLEAN) || type.getCanonicalText().equals(Boolean.class.toString())) {
+            booleanParamExists = true;
+            break;
+          }
+        }
+
+        if (!booleanParamExists) {
+          return false;
+        }
+      }
+      // Else it's ASSERT_IS_NULL_METHOD or ASSERT_IS_NOT_NULL_METHOD.
+      // In that case there is no additional validation
+
+      return true;
+    }
+
+    private boolean isMethodFromJavaLangObject(PsiMethod method) {
+      if (method != null && method.getContainingClass() != null && method.getContainingClass().getName() != null &&
+          (method.getContainingClass().getName().equals("Object") || method.getContainingClass().getName().equals(Object.class.toString()))) {
+        return true;
+      }
+
+      return false;
+    }
+
+    @Override
+    public void propertyChange(PropertyChangeEvent evt) {
+      if (evt.getPropertyName().equals(ClassField.PROPERTY_PSICLASS)) {
+        if (evt.getNewValue() == null) {
+          clear();
+        } else {
+          setEnabled(true);
+          if (myPsiClass == null || !myPsiClass.equals(evt.getNewValue())) { // ClassChanged so refresh list
+            myPsiClass = (PsiClass) evt.getNewValue();
+            initValues();
+          }
+        }
+      }
+    }
+
+    public void clear() {
+      myModel.clear();
+      myModel.setSelectedItem(null);
+      setEnabled(false);
+      myPsiClass = null;
+    }
+
+    public static SortedComboBoxModel<MethodWrapper> buildModel() {
+      return new SortedComboBoxModel<MethodWrapper>(new Comparator<MethodWrapper>() {
+        @Override
+        public int compare(MethodWrapper o1, MethodWrapper o2) {
+          return o1.compareTo(o2);
+        }
+      });
+    }
+
+    public PsiMethod getSelectedPsiMethod() {
+      MethodWrapper methodWrapper = myModel.getSelectedItem();
+      if (methodWrapper == null)
+        return null;
+
+      return methodWrapper.getPsiMethod();
+    }
+  }
+
+  /**
+   * Drop Down for picking Parameter Name
+   */
+  static class ParameterDropDown extends JComboBox implements PropertyChangeListener, ItemListener {
+    private @Nullable PsiMethod myPsiMethod;
+    private final @NotNull SortedComboBoxModel<ParameterWrapper> myModel;
+    private final @NotNull ConditionChecker.Type myType;
+    public static final String PROPERTY_PARAMETERDROPDOWN = "ParameterDropDown.myModel";
+
+    public ParameterDropDown(@Nullable PsiMethod psiMethod, @Nullable PsiParameter psiParameter, @NotNull SortedComboBoxModel<ParameterWrapper> model, @NotNull ConditionChecker.Type type) {
+      super(model);
+
+      if (!isSupported(type))
+        throw new IllegalArgumentException("Type is invalid " + type);
+
+      myPsiMethod = psiMethod;
+      myModel = model;
+      myType = type;
+
+      if (myPsiMethod != null) {
+        setEnabled(true);
+        myModel.addAll(getParameterWrappers());
+        if (psiParameter != null) {
+          for (Iterator iterator = myModel.iterator(); iterator.hasNext(); ) {
+            ParameterWrapper wrapper = (ParameterWrapper) iterator.next();
+            if (wrapper.getPsiParameter().equals(psiParameter))
+              setSelectedItem(wrapper);
+          }
+        }
+      } else {
+        setEnabled(false);
+      }
+    }
+
+    List<ParameterWrapper> getParameterWrappers() {
+      List<ParameterWrapper> wrappers = new ArrayList<ParameterWrapper>();
+      if (myPsiMethod != null) {
+        PsiParameterList parameterList = myPsiMethod.getParameterList();
+        for (int i = 0; i < parameterList.getParameters().length; i++) {
+          PsiParameter psiParameter = parameterList.getParameters()[i];
+          if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
+            PsiType type = psiParameter.getType();
+            if (type.equals(PsiType.BOOLEAN) || type.getCanonicalText().equals(Boolean.class.toString()))
+              wrappers.add(new ParameterWrapper(psiParameter, i));
+          } else {
+            wrappers.add(new ParameterWrapper(psiParameter, i));
+          }
+
+        }
+      }
+      return wrappers;
+    }
+
+    public static SortedComboBoxModel<ParameterWrapper> buildModel() {
+      return new SortedComboBoxModel<ParameterWrapper>(new Comparator<ParameterWrapper>() {
+        @Override
+        public int compare(ParameterWrapper o1, ParameterWrapper o2) {
+          return o1.compareTo(o2);
+        }
+      });
+    }
+
+    @Override
+    public void itemStateChanged(ItemEvent e) {
+      if (e.getSource() instanceof MethodDropDown) { // The MethodDropDown has changed.
+        MethodDropDown methodDropDown = (MethodDropDown) e.getSource();
+        if (methodDropDown.getSelectedPsiMethod() != null) {
+          setEnabled(true);
+          if (myPsiMethod == null || !myPsiMethod.equals(methodDropDown.getSelectedPsiMethod())) {
+            myPsiMethod = methodDropDown.getSelectedPsiMethod();
+            myModel.clear();
+            myModel.addAll(getParameterWrappers());
+            myModel.setSelectedItem(null);
+          }
+        } else {
+          myPsiMethod = null;
+          myModel.clear();
+          myModel.setSelectedItem(null);
+          setEnabled(false);
+        }
+      } else {
+        throw new RuntimeException("Unexpected Configuration ParameterDropDown is only expected to receive events from MethodDropDown.");
+      }
+    }
+
+    @Override
+    public void propertyChange(PropertyChangeEvent evt) {
+      if (evt.getPropertyName().equals(ClassField.PROPERTY_PSICLASS)) {
+        if (evt.getNewValue() == null) {
+          setEnabled(false);
+        }
+      }
+    }
+
+    public PsiParameter getSelectedPsiParameter() {
+      ParameterWrapper parameterWrapper = myModel.getSelectedItem();
+      if (parameterWrapper == null)
+        return null;
+
+      return parameterWrapper.getPsiParameter();
+    }
+
+    class ParameterWrapper implements Comparable<ParameterWrapper> {
+      private final @NotNull String id;
+      private final @NotNull PsiParameter psiParameter;
+      private final int index;
+
+      ParameterWrapper(@NotNull PsiParameter psiParameter, int index) {
+        this.psiParameter = psiParameter;
+        this.index = index;
+        String typeName;
+        PsiTypeElement typeElement = psiParameter.getTypeElement();
+        if (typeElement == null) {
+          typeName = "";
+        } else {
+          if (typeElement.getType() instanceof PsiPrimitiveType) {
+            typeName = ((PsiPrimitiveType) typeElement.getType()).getBoxedTypeName();
+          } else {
+            typeName = typeElement.getType().getCanonicalText();
+          }
+        }
+
+        id = typeName + " " + psiParameter.getName();
+      }
+
+      @Override
+      public int compareTo(ParameterWrapper o) {
+        return index - o.index;
+      }
+
+      @Override
+      public String toString() {
+        return id;
+      }
+
+      @NotNull
+      public PsiParameter getPsiParameter() {
+        return psiParameter;
+      }
+    }
+  }
+
+  static class MethodWrapper implements Comparable<MethodWrapper> {
+    private final @NotNull PsiMethod myPsiMethod;
+    private final @NotNull String myId;
+
+    MethodWrapper(@NotNull PsiMethod psiMethod) {
+      this.myPsiMethod = psiMethod;
+
+      List<String> parameters = new ArrayList<String>();
+      for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
+        PsiParameter psiParameter = psiMethod.getParameterList().getParameters()[i];
+        parameters.add(getParameterQualifiedName(psiParameter));
+      }
+
+      myId = initId(psiMethod.getName(), parameters);
+    }
+
+    private String getParameterQualifiedName(PsiParameter psiParameter) {
+      PsiTypeElement typeElement = psiParameter.getTypeElement();
+      if (typeElement == null) {
+        return "";
+      }
+
+      if (typeElement.getType() instanceof PsiPrimitiveType) {
+        return ((PsiPrimitiveType) typeElement.getType()).getBoxedTypeName();
+      }
+
+      return typeElement.getType().getCanonicalText();
+    }
+
+    private String initId(String methodName, List<String> parameterNames) {
+      String shortName = methodName + "(";
+      for (String parameterName : parameterNames) {
+        if (parameterNames.lastIndexOf("") > -1)
+          shortName += parameterName.substring(parameterName.lastIndexOf("") + 1) + ", ";
+        else
+          shortName += parameterName + ", ";
+      }
+
+      if (parameterNames.size() > 0)
+        shortName = shortName.substring(0, shortName.lastIndexOf(", "));
+
+      shortName += ")";
+      return shortName;
+    }
+
+    @NotNull
+    public PsiMethod getPsiMethod() {
+      return myPsiMethod;
+    }
+
+    @NotNull
+    public String getId() {
+      return myId;
+    }
+
+    @Override
+    public String toString() {
+      return myId;
+    }
+
+    @Override
+    public int compareTo(MethodWrapper o) {
+      return myId.compareTo(o.myId);
+    }
+  }
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/AssertFalse.java b/java/java-tests/testData/inspection/dataFlow/fixture/AssertFalse.java
new file mode 100644
index 000000000000..3aa73afcff5b
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/AssertFalse.java
@@ -0,0 +1,9 @@
+public class AssertFalse {
+   void bar() {
+     final boolean b = call();
+     if (Assertions.assertFalse(b)) {
+       if(<warning descr="Condition 'b' is always 'false'">b</warning>) {}
+     }
+   }
+   boolean call() {return true;}
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNotNull.java b/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNotNull.java
new file mode 100644
index 000000000000..5b16eb78ac7b
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNotNull.java
@@ -0,0 +1,10 @@
+import java.lang.*;
+
+public class AssertIsNotNull {
+  void bar() {
+    final Object o = call();
+    Assertions.assertIsNotNull(o);
+    if(<warning descr="Condition 'o == null' is always 'false'">o == null</warning>) {}
+  }
+  Object call() {return new Object();}
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNull.java b/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNull.java
new file mode 100644
index 000000000000..5915277cc273
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/AssertIsNull.java
@@ -0,0 +1,10 @@
+import java.lang.*;
+
+public class AssertIsNull {
+   void bar() {
+     final Object o = call();
+     Assertions.assertIsNull(o);
+     if(<warning descr="Condition 'o == null' is always 'true'">o == null</warning>) {}
+   }
+   Object call() {return new Object();}
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/AssertTrue.java b/java/java-tests/testData/inspection/dataFlow/fixture/AssertTrue.java
new file mode 100644
index 000000000000..a71e4382ab44
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/AssertTrue.java
@@ -0,0 +1,9 @@
+public class AssertTrue {
+   void bar() {
+     final boolean b = call();
+     if (Assertions.assertTrue(b)) {
+       if(<warning descr="Condition 'b' is always 'true'">b</warning>) {}
+     }
+   }
+   boolean call() {return true;}
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/IsNotNullCheck.java b/java/java-tests/testData/inspection/dataFlow/fixture/IsNotNullCheck.java
new file mode 100644
index 000000000000..85879eda40a7
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/IsNotNullCheck.java
@@ -0,0 +1,9 @@
+public class IsNotNullCheck {
+   void bar() {
+     final Value v = call();
+     if (Value.isNotNull(v)) {
+       if(<warning descr="Condition 'v == null' is always 'false'">v == null</warning>) {}
+     }
+   }
+    Value call() {return new Value();}
+}
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/IsNullCheck.java b/java/java-tests/testData/inspection/dataFlow/fixture/IsNullCheck.java
new file mode 100644
index 000000000000..1b2c48593a16
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/IsNullCheck.java
@@ -0,0 +1,9 @@
+public class IsNullCheck {
+   void bar() {
+     final Value v = call();
+     if (Value.isNull(v)) {
+       if(<warning descr="Condition 'v == null' is always 'true'">v == null</warning>) {}
+     }
+   }
+    Value call() {return new Value();}
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
index 56fa8115d95f..fb8f28866961 100644
--- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
@@ -16,12 +16,19 @@
 package com.intellij.codeInspection;
 
 import com.intellij.JavaTestUtil;
+import com.intellij.codeInsight.ConditionCheckManager;
+import com.intellij.codeInsight.ConditionChecker;
+import com.intellij.codeInsight.MethodConditionCheck;
 import com.intellij.codeInsight.NullableNotNullManager;
 import com.intellij.codeInspection.dataFlow.DataFlowInspection;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 
+import java.io.IOException;
+
 /**
  * @author peter
  */
@@ -158,4 +165,60 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase {
 
   public void testEqualsHasNoSideEffects() { doTest(); }
 
+  public void testIsNullCheck() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getIsNullCheckMethods().add(
+      buildMethodConditionCheck("Value", "isNull", ConditionChecker.Type.IS_NULL_METHOD,
+                                "public class Value { public static boolean isNull(Value o) {if (o == null) return true; else return false;} }"));
+    doTest();
+  }
+
+  public void testIsNotNullCheck() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getIsNotNullCheckMethods().add(
+      buildMethodConditionCheck("Value", "isNotNull", ConditionChecker.Type.IS_NOT_NULL_METHOD,
+                                "public class Value { public static boolean isNotNull(Value o) {if (o == null) return false; else return true;} }"));
+    doTest();
+  }
+
+  public void testAssertTrue() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getAssertTrueMethods().add(
+      buildMethodConditionCheck("Assertions", "assertTrue", ConditionChecker.Type.ASSERT_TRUE_METHOD,
+                                "public class Assertions { public static boolean assertTrue(boolean b) {if(!b) throw new Exception();} }"));
+    doTest();
+  }
+
+  public void testAssertFalse() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getAssertFalseMethods().add(
+      buildMethodConditionCheck("Assertions", "assertFalse", ConditionChecker.Type.ASSERT_FALSE_METHOD,
+                                "public class Assertions { public static boolean assertFalse(boolean b) {if(b) throw new Exception();} }"));
+    doTest();
+  }
+
+  public void testAssertIsNull() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getAssertIsNullMethods().add(
+      buildMethodConditionCheck("Assertions", "assertIsNull", ConditionChecker.Type.ASSERT_IS_NULL_METHOD,
+                                "public class Assertions { public static boolean assertIsNull(Object o) {if(o != null) throw new Exception();} }"));
+    doTest();
+  }
+
+  public void testAssertIsNotNull() throws Exception {
+    ConditionCheckManager.getInstance(myModule.getProject()).getAssertIsNotNullMethods().add(
+      buildMethodConditionCheck("Assertions", "assertIsNotNull", ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD,
+                                "public class Assertions { public static boolean assertIsNotNull(Object o) {if(o == null) throw new Exception();} }"));
+    doTest();
+  }
+
+  private MethodConditionCheck buildMethodConditionCheck(String className, String methodName, ConditionChecker.Type type, String classText)
+    throws IOException {
+    myFixture.addClass(classText);
+    PsiClass psiClass = myFixture.findClass(className);
+    PsiMethod psiMethod = null;
+    PsiMethod[] methods = psiClass.getMethods();
+    for (PsiMethod tempPsiMethod : methods) {
+      if (tempPsiMethod.getName().equals(methodName)) {
+        psiMethod = tempPsiMethod;
+        break;
+      }
+    }
+    return new MethodConditionCheck(psiMethod, psiMethod.getParameterList().getParameters()[0], type);
+  }
 }
diff --git a/platform/platform-resources-en/src/messages/InspectionsBundle.properties b/platform/platform-resources-en/src/messages/InspectionsBundle.properties
index 084f692e3dc8..663c46229631 100644
--- a/platform/platform-resources-en/src/messages/InspectionsBundle.properties
+++ b/platform/platform-resources-en/src/messages/InspectionsBundle.properties
@@ -51,6 +51,22 @@ inspection.data.flow.redundant.instanceof.quickfix=Replace with != null
 inspection.data.flow.simplify.boolean.expression.quickfix=Simplify Boolean Expression
 inspection.data.flow.simplify.to.assignment.quickfix.name=Simplify to normal assignment
 configure.annotations.option=Configure annotations
+configure.checker.option.button=Configure IsNull/IsNotNull/True/False Check/Assert Methods
+configure.checker.option.main.dialog.title=IsNull/IsNotNull Configuration
+configure.checker.option.overlap.error.title=Overlapping Check
+configure.checker.option.overlap.error.msg=Configuration conflicts with
+configure.checker.option.isNull.add.method.checker.dialog.title=Add IsNull Check Method
+configure.checker.option.isNotNull.add.method.checker.dialog.title=Add IsNotNull Check Method
+configure.checker.option.assert.isNull.add.method.checker.dialog.title=Add Assert IsNull Method
+configure.checker.option.assert.isNotNull.add.method.checker.dialog.title=Add Assert IsNotNull Method
+configure.checker.option.assert.true.add.method.checker.dialog.title=Add Assert True Method
+configure.checker.option.assert.false.add.method.checker.dialog.title=Add Assert False Method
+configure.checker.option.assert.isNull.method.panel.title=Assert IsNull Methods
+configure.checker.option.assert.isNotNull.method.panel.title=Assert IsNotNull Methods
+configure.checker.option.isNull.method.panel.title=IsNull Check Methods
+configure.checker.option.isNotNull.method.panel.title=IsNotNull Check Methods
+configure.checker.option.assert.true.method.panel.title=Assert True Methods
+configure.checker.option.assert.false.method.panel.title=Assert False Methods
 
 #messages from dataflow inspection
 dataflow.message.npe.method.invocation=Method invocation <code>#ref</code> #loc may produce <code>java.lang.NullPointerException</code>
diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml
index a9768a9a1cef..3c635fe04277 100644
--- a/resources/src/META-INF/IdeaPlugin.xml
+++ b/resources/src/META-INF/IdeaPlugin.xml
@@ -433,6 +433,9 @@
     <projectService serviceInterface="com.intellij.codeInsight.NullableNotNullManager"
                     serviceImplementation="com.intellij.codeInsight.NullableNotNullManagerImpl"/>
 
+    <projectService serviceInterface="com.intellij.codeInsight.ConditionCheckManager"
+                    serviceImplementation="com.intellij.codeInsight.ConditionCheckManager"/>
+
     <projectService serviceInterface="com.intellij.psi.search.PsiShortNamesCache"
                     serviceImplementation="com.intellij.psi.impl.CompositeShortNamesCache"/>
 

From b34abcdbbc48bdfe6d7919a7601078ad6bd9da25 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Thu, 21 Feb 2013 11:21:30 +0100
Subject: [PATCH 002/354] don't hold Project in statics

---
 .../com/intellij/codeInsight/ConditionCheckManager.java    | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
index 539a3a1b231a..92676fc2ecef 100644
--- a/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
@@ -45,10 +45,13 @@ public class ConditionCheckManager implements PersistentStateComponent<Condition
   private List<MethodConditionCheck> myAssertTrueMethods = new ArrayList<MethodConditionCheck>();
   private List<MethodConditionCheck> myAssertFalseMethods = new ArrayList<MethodConditionCheck>();
 
-  private static Project myProject;
+  private Project myProject;
+
+  public ConditionCheckManager(Project project) {
+    myProject = project;
+  }
 
   public static ConditionCheckManager getInstance(Project project) {
-    myProject = project;
     return ServiceManager.getService(project, ConditionCheckManager.class);
   }
 

From 7beb260d2331851eb98d1f6e853e6e20c5b8014d Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Thu, 21 Feb 2013 11:42:59 +0100
Subject: [PATCH 003/354] @NotNull

---
 .../src/com/intellij/codeInsight/ConditionChecker.java          | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
index ffcbb3c57558..3fb86a0d48b0 100644
--- a/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
@@ -16,6 +16,7 @@
 package com.intellij.codeInsight;
 
 import com.intellij.psi.*;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Interface for IsNull, IsNotNull Method Checks and Assert True/False/IsNull/IsNotNull Method Checks to be performed by the Constant Condition Inspection.
@@ -51,5 +52,6 @@ public interface ConditionChecker {
 
   boolean overlaps(ConditionChecker checker);
 
+  @NotNull
   Type getType();
 }

From 54ff2eb7a2951d36e7a025777e5f41ba11e30ea6 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Thu, 21 Feb 2013 11:43:48 +0100
Subject: [PATCH 004/354] fix some idea warnings

---
 .../codeInsight/MethodConditionCheck.java       | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java b/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
index b8f1afbf9442..46c3121d6619 100644
--- a/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
+++ b/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
@@ -154,6 +154,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
     return false;
   }
 
+  @NotNull
   @Override
   public Type getType() {
     return myType;
@@ -161,7 +162,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
 
   private void validatePsiMethod() {
     PsiElement psiElement = myPsiMethod.getContainingClass();
-    if (!(psiElement instanceof PsiClass))
+    if (psiElement == null)
       throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " can not have a null containing class.");
 
     PsiType returnType = myPsiMethod.getReturnType();
@@ -192,9 +193,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
   }
 
   private String initClassNameFromPsiMethod() {
-    PsiElement psiElement = myPsiMethod.getContainingClass();
-    PsiClass psiClass = (PsiClass) psiElement;
-    return psiClass.getQualifiedName();
+    return myPsiMethod.getContainingClass().getQualifiedName();
   }
 
   private String initMethodNameFromPsiMethod() {
@@ -224,7 +223,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
     return psiType.getCanonicalText() + " " + psiParameter.getName();
   }
 
-  private String initFullName(String className, String methodName, List<String> parameters) {
+  private static String initFullName(String className, String methodName, List<String> parameters) {
     String s = className + "." + methodName + "(";
     for (String parameterName : parameters) {
       s += parameterName + ", ";
@@ -234,7 +233,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
     return s;
   }
 
-  private String initShortName(String methodName, List<String> parameterNames) {
+  private static String initShortName(String methodName, List<String> parameterNames) {
     String shortName = methodName + "(";
     for (String parameterName : parameterNames) {
       if (parameterNames.lastIndexOf(".") > -1)
@@ -330,7 +329,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
       return new MethodConditionCheck(psiMethod, psiParameter, type);
     }
 
-    private String parseClassNameAndMethodName(String fullyQualifiedClassMethodAndParameterName) {
+    private static String parseClassNameAndMethodName(String fullyQualifiedClassMethodAndParameterName) {
       if (!fullyQualifiedClassMethodAndParameterName.contains("(")) {
         throw new IllegalArgumentException("Name should contain a opening parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
       } else if (!fullyQualifiedClassMethodAndParameterName.contains(")")) {
@@ -350,7 +349,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
       return classNameAndMethodName;
     }
 
-    private PsiMethod findPsiMethodWithMatchingParameters(List<PsiMethod> psiMethods, String allParametersSubString) {
+    private static PsiMethod findPsiMethodWithMatchingParameters(List<PsiMethod> psiMethods, String allParametersSubString) {
       String[] parameterClassAndNameArray = allParametersSubString.split(",");
       List<String> parameterClassToMatch = new ArrayList<String>();
       for (String parameterClassAndName : parameterClassAndNameArray) {
@@ -378,7 +377,7 @@ public class MethodConditionCheck implements ConditionChecker, Comparable<Method
       return null;
     }
 
-    private List<PsiMethod> findPsiMethodsInPsiClassWithMatchingMethodName(PsiClass psiClass, String methodName) {
+    private static List<PsiMethod> findPsiMethodsInPsiClassWithMatchingMethodName(PsiClass psiClass, String methodName) {
       List<PsiMethod> psiMethods = new ArrayList<PsiMethod>();
       for (int i = 0; i < psiClass.getMethods().length; i++) {
         PsiMethod possibleMatchPsiMethod = psiClass.getMethods()[i];

From 29536cfc57062211794dcf75a2ddf8c402b5b4e3 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Thu, 21 Feb 2013 17:20:49 +0400
Subject: [PATCH 005/354] IDEA-99659 Groovy: don't complete anonymous class or
 instance where array is expected

---
 .../GroovyExpectedTypesProvider.java            | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/expectedTypes/GroovyExpectedTypesProvider.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/expectedTypes/GroovyExpectedTypesProvider.java
index 487703eec40c..6f020e2262c4 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/expectedTypes/GroovyExpectedTypesProvider.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/expectedTypes/GroovyExpectedTypesProvider.java
@@ -20,7 +20,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.psi.*;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.ArrayUtilRt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.codeInspection.utils.ControlFlowUtils;
@@ -210,10 +209,7 @@ public class GroovyExpectedTypesProvider {
           final GrArgumentList argumentList = methodCall.getArgumentList();
           final GrNamedArgument[] namedArgs = argumentList == null ? GrNamedArgument.EMPTY_ARRAY : argumentList.getNamedArguments();
           final GrExpression[] expressionArgs = argumentList == null ? GrExpression.EMPTY_ARRAY : argumentList.getExpressionArguments();
-          addConstraintsFromMap(constraints,
-                                GrClosureSignatureUtil.mapArgumentsToParameters(variant, methodCall, true, true, namedArgs, expressionArgs,
-                                                                                closureArgs),
-                                closureIndex == closureArgs.length - 1);
+          addConstraintsFromMap(constraints, GrClosureSignatureUtil.mapArgumentsToParameters(variant, methodCall, true, true, namedArgs, expressionArgs, closureArgs));
         }
         if (!constraints.isEmpty()) {
           myResult = constraints.toArray(new TypeConstraint[constraints.size()]);
@@ -378,11 +374,10 @@ public class GroovyExpectedTypesProvider {
     public void visitArgumentList(GrArgumentList list) {
       List<TypeConstraint> constraints = new ArrayList<TypeConstraint>();
       for (GroovyResolveResult variant : ResolveUtil.getCallVariants(list)) {
-        final GrExpression[] arguments = list.getExpressionArguments();
         final Map<GrExpression, Pair<PsiParameter, PsiType>> map = GrClosureSignatureUtil.mapArgumentsToParameters(
           variant, list, true, true, list.getNamedArguments(), list.getExpressionArguments(), GrClosableBlock.EMPTY_ARRAY
         );
-        addConstraintsFromMap(constraints, map, ArrayUtilRt.find(arguments, myExpression) == arguments.length - 1);
+        addConstraintsFromMap(constraints, map);
       }
       if (!constraints.isEmpty()) {
         myResult = constraints.toArray(new TypeConstraint[constraints.size()]);
@@ -428,9 +423,7 @@ public class GroovyExpectedTypesProvider {
       }
     }
 
-    private void addConstraintsFromMap(List<TypeConstraint> constraints,
-                                       Map<GrExpression, Pair<PsiParameter, PsiType>> map,
-                                       boolean isLast) {
+    private void addConstraintsFromMap(List<TypeConstraint> constraints, Map<GrExpression, Pair<PsiParameter, PsiType>> map) {
       if (map == null) return;
 
       final Pair<PsiParameter, PsiType> pair = map.get(myExpression);
@@ -441,7 +434,7 @@ public class GroovyExpectedTypesProvider {
 
       constraints.add(SubtypeConstraint.create(type));
 
-      if (type instanceof PsiArrayType && isLast) {
+      if (type instanceof PsiArrayType && pair.first.isVarArgs()) {
         constraints.add(SubtypeConstraint.create(((PsiArrayType)type).getComponentType()));
       }
     }
@@ -517,7 +510,7 @@ public class GroovyExpectedTypesProvider {
     @Override
     public void visitListOrMap(GrListOrMap listOrMap) {
       if (listOrMap.isMap()) return;
-      final TypeConstraint[] constraints = GroovyExpectedTypesProvider.calculateTypeConstraints(listOrMap);
+      final TypeConstraint[] constraints = calculateTypeConstraints(listOrMap);
       List<PsiType> result=new ArrayList<PsiType>(constraints.length);
       for (TypeConstraint constraint : constraints) {
         if (constraint instanceof SubtypeConstraint) {

From 17d102bc9b407dc4c7092c1ae900028752f6d52d Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Thu, 21 Feb 2013 17:48:59 +0400
Subject: [PATCH 006/354] IDEA-95898 Gradle based projects should offer
 Auto-Import as Maven projects do

Iteration 3: there is a component which knows how to resolve project structure changes. Auto-importer now delegates to it
---
 .../resources/i18n/GradleBundle.properties    |   2 +-
 plugins/gradle/src/META-INF/plugin.xml        |   2 +
 .../gradle/autoimport/GradleAutoImporter.java |  43 ++-
 .../GradleUserProjectChangesCalculator.java   |   9 +-
 .../gradle/config/GradleConfigNotifier.java   |   2 +
 .../config/GradleConfigNotifierAdapter.java   |   4 +
 .../gradle/config/GradleConfigurable.java     |  40 ++-
 .../plugins/gradle/config/GradleSettings.java |  20 ++
 .../gradle/config/GradleToolWindowPanel.java  |   3 +-
 .../manage/GradleDependencyManager.java       |  21 ++
 .../manage/GradleEntityManageHelper.java      | 316 +++++++++++++++++-
 .../gradle/manage/GradleModuleManager.java    |  37 +-
 .../manage/GradleProjectImportBuilder.java    |   1 +
 .../gradle/manage/GradleProjectManager.java   |  55 +++
 ...GradleProjectStructureChangesDetector.java |  13 +-
 .../GradleProjectStructureChangesModel.java   |   3 +
 .../sync/GradleProjectStructureHelper.java    |  10 +
 .../sync/GradleProjectStructureTreeModel.java |   6 +-
 18 files changed, 542 insertions(+), 45 deletions(-)
 create mode 100644 plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectManager.java

diff --git a/plugins/gradle/resources/i18n/GradleBundle.properties b/plugins/gradle/resources/i18n/GradleBundle.properties
index b90dc5b5e3cc..f99b6cd319ad 100644
--- a/plugins/gradle/resources/i18n/GradleBundle.properties
+++ b/plugins/gradle/resources/i18n/GradleBundle.properties
@@ -11,7 +11,7 @@ gradle.settings.label.select.project=Gradle project:
 gradle.settings.text.home.path=Gradle home:
 gradle.settings.text.service.dir.path=Service directory path:
 gradle.settings.title.service.dir.path=Select gradle service directory to use
-gradle.import.title.select.project=Select project to import
+gradle.settings.use.auto.import=Use auto-import
 gradle.import.progress.text=Building Gradle project info
 gradle.import.label.project.structure=Project structure:
 gradle.import.label.details=Details:
diff --git a/plugins/gradle/src/META-INF/plugin.xml b/plugins/gradle/src/META-INF/plugin.xml
index 39464102bab4..a981413c392e 100644
--- a/plugins/gradle/src/META-INF/plugin.xml
+++ b/plugins/gradle/src/META-INF/plugin.xml
@@ -46,6 +46,7 @@
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.diff.dependency.GradleLibraryDependencyStructureChangesCalculator"/>
     
     <!--Project structure management services-->
+    <applicationService serviceImplementation="org.jetbrains.plugins.gradle.manage.GradleProjectManager"/>
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.manage.GradleModuleManager"/>
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.manage.GradleLibraryManager"/>
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.manage.GradleJarManager"/>
@@ -56,6 +57,7 @@
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.sync.GradleDuplicateLibrariesPreProcessor"/>
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.sync.GradleMovedJarsPostProcessor"/>
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.sync.GradleOutdatedLibraryVersionPostProcessor"/>
+    <applicationService serviceImplementation="org.jetbrains.plugins.gradle.autoimport.GradleAutoImporter"/>
 
     <!--Generic application services-->
     <applicationService serviceImplementation="org.jetbrains.plugins.gradle.remote.GradleApiFacadeManager"/>
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleAutoImporter.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleAutoImporter.java
index 3c61caa5344f..5610330f3948 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleAutoImporter.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleAutoImporter.java
@@ -15,12 +15,18 @@
  */
 package org.jetbrains.plugins.gradle.autoimport;
 
+import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.gradle.config.GradleLocalSettings;
+import org.jetbrains.plugins.gradle.config.GradleSettings;
 import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChange;
+import org.jetbrains.plugins.gradle.manage.GradleEntityManageHelper;
 import org.jetbrains.plugins.gradle.sync.GradleProjectStructureChangesPostProcessor;
 
 import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Automates a task of keeping gradle and ide projects in sync,
@@ -29,19 +35,50 @@ import java.util.Collection;
  * Consider a situation when a user, say, renames a module (gradle sub-project). We would like not only import new module
  * but remove the old one as well. Unfortunately, we don't have api for distinguishing change like 'gradle sub-project remove'
  * from 'new module is added to the project by a user'. They both look like 'new ide-local module'. That's why we use the following
- * algorithm here:
- * // TODO den add doc
+ * algorithm for every project structure change here:
+ * <pre>
+ * <ol>
+ *   <li>
+ *     Check if there is an {@link GradleUserProjectChange explicitly made project structure change} for the current project
+ *     structure change;
+ *   </li>
+ *   <li>
+ *     {@link GradleEntityManageHelper#eliminateChange(Collection, Set, boolean) Resolve the change} if it doesn't occur
+ *     because of user actions (e.g. we don't want to auto-remove a module which is absent at gradle but presents at IDE);
+ *   </li>
+ * </ol>
+ * </pre>
  * 
  * @author Denis Zhdanov
  * @since 2/18/13 7:55 PM
  */
 public class GradleAutoImporter implements GradleProjectStructureChangesPostProcessor {
+
+  @NotNull private final AtomicBoolean myInProgress = new AtomicBoolean();
+
+  public boolean isInProgress() {
+    return myInProgress.get();
+  }
   
   @Override
   public void processChanges(@NotNull Collection<GradleProjectStructureChange> changes,
                              @NotNull Project project,
                              boolean onIdeProjectStructureChange)
   {
-    // TODO den implement 
+    if (onIdeProjectStructureChange || !GradleSettings.getInstance(project).isUseAutoImport()) {
+      return;
+    }
+    GradleLocalSettings settings = GradleLocalSettings.getInstance(project);
+    GradleEntityManageHelper manageHelper = ServiceManager.getService(project, GradleEntityManageHelper.class);
+    Set<GradleProjectStructureChange> nonProcessed;
+    myInProgress.set(true);
+    try {
+      nonProcessed = manageHelper.eliminateChange(changes, settings.getUserProjectChanges(), true);
+    }
+    finally {
+      myInProgress.set(false);
+    }
+    changes.clear();
+    changes.addAll(nonProcessed);
   }
 }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
index e47866f54240..316d87aa4e0b 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
@@ -89,6 +89,7 @@ public class GradleUserProjectChangesCalculator {
   public GradleProject updateCurrentProjectState() {
     GradleProject state = buildCurrentIdeProject();
     myLastProjectState = state;
+    filterOutdatedChanges();
     return state;
   }
 
@@ -101,10 +102,8 @@ public class GradleUserProjectChangesCalculator {
   public void updateChanges() {
     GradleProject lastProjectState = myLastProjectState;
     if (lastProjectState == null) {
-      lastProjectState = updateCurrentProjectState();
-      if (lastProjectState == null) {
-        return;
-      }
+      updateCurrentProjectState();
+      return;
     }
 
     GradleProject currentProjectState = buildCurrentIdeProject();
@@ -116,6 +115,8 @@ public class GradleUserProjectChangesCalculator {
 
     buildModulePresenceChanges(context);
     buildDependencyPresenceChanges(context);
+    filterOutdatedChanges();
+    context.currentChanges.addAll(mySettings.getUserProjectChanges());
     mySettings.setUserProjectChanges(context.currentChanges);
     myLastProjectState = currentProjectState;
   }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifier.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifier.java
index ccef16d19bfd..ccdb0e6b0f66 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifier.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifier.java
@@ -55,6 +55,8 @@ public interface GradleConfigNotifier {
    * @see GradleSettings#getServiceDirectoryPath() 
    */
   void onServiceDirectoryPathChange(@Nullable String oldPath, @Nullable String newPath);
+
+  void onUseAutoImportChange(boolean oldValue, boolean newValue);
   
   /**
    * Gradle settings changes might affect project structure, e.g. switching from one gradle version to another one or from
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifierAdapter.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifierAdapter.java
index 9d4883f46b4a..4da511c94955 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifierAdapter.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigNotifierAdapter.java
@@ -24,6 +24,10 @@ public abstract class GradleConfigNotifierAdapter implements GradleConfigNotifie
   public void onServiceDirectoryPathChange(@Nullable String oldPath, @Nullable String newPath) {
   }
 
+  @Override
+  public void onUseAutoImportChange(boolean oldValue, boolean newValue) {
+  }
+
   @Override
   public void onBulkChangeStart() {
   }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
index c708792b397b..eff3351ed109 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
@@ -26,6 +26,7 @@ import com.intellij.openapi.ui.TextComponentAccessor;
 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.ui.components.JBCheckBox;
 import com.intellij.ui.components.JBLabel;
 import com.intellij.ui.components.JBRadioButton;
 import com.intellij.util.Alarm;
@@ -64,7 +65,7 @@ import java.util.concurrent.TimeUnit;
 public class GradleConfigurable implements SearchableConfigurable, Configurable.NoScroll {
   
   private enum PathColor { NORMAL, DEDUCED }
-  
+
   @NonNls public static final String HELP_TOPIC = "reference.settingsdialog.project.gradle";
 
   private static final long BALLOON_DELAY_MILLIS = TimeUnit.SECONDS.toMillis(1);
@@ -77,8 +78,8 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
 
   @NotNull private GradleHomeSettingType myGradleHomeSettingType = GradleHomeSettingType.UNKNOWN;
 
-  @NotNull private final JLabel myLinkedProjectLabel = new JBLabel(GradleBundle.message("gradle.settings.label.select.project"));
-  @NotNull private final JLabel myGradleHomeLabel    = new JBLabel(GradleBundle.message("gradle.settings.text.home.path"));
+  @NotNull private final JLabel myLinkedProjectLabel    = new JBLabel(GradleBundle.message("gradle.settings.label.select.project"));
+  @NotNull private final JLabel myGradleHomeLabel       = new JBLabel(GradleBundle.message("gradle.settings.text.home.path"));
   @NotNull private final JLabel myServiceDirectoryLabel = new JBLabel(GradleBundle.message("gradle.settings.text.service.dir.path"));
 
   @NotNull private TextFieldWithBrowseButton myLinkedGradleProjectPathField;
@@ -86,6 +87,7 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
   @NotNull private TextFieldWithBrowseButton myServiceDirectoryPathField;
   @NotNull private JBRadioButton             myUseWrapperButton;
   @NotNull private JBRadioButton             myUseLocalDistributionButton;
+  @NotNull private JBCheckBox                myUseAutoImportBox;
 
   @Nullable private JComponent myComponent;
 
@@ -156,6 +158,10 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     return myUseLocalDistributionButton.isSelected();
   }
 
+  public boolean isUseAutoImport() {
+    return myUseAutoImportBox.isSelected();
+  }
+
   public void setLinkedGradleProjectPath(@NotNull String path) {
     myLinkedGradleProjectPathField.setText(path);
   }
@@ -175,24 +181,27 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     initWrapperVsLocalControls();
     initGradleHome(testMode);
     initServiceDirectoryHome();
+    myUseAutoImportBox = new JBCheckBox(GradleBundle.message("gradle.settings.use.auto.import"));
     assert myComponent != null;
 
     GridBag pathLabelConstraints = new GridBag().anchor(GridBagConstraints.WEST).weightx(0);
-    GridBag pathConstraints = new GridBag().weightx(1).coverLine().fillCellHorizontally().anchor(GridBagConstraints.WEST);
+    GridBag fillLineConstraints = new GridBag().weightx(1).coverLine().fillCellHorizontally().anchor(GridBagConstraints.WEST);
     myComponent.add(myLinkedProjectLabel, pathLabelConstraints);
-    myComponent.add(myLinkedGradleProjectPathField, pathConstraints);
+    myComponent.add(myLinkedGradleProjectPathField, fillLineConstraints);
 
     GridBag constraints = new GridBag().coverLine().anchor(GridBagConstraints.WEST);
-    
+
     // Provide radio buttons if gradle wrapper can be used for particular project.
     myComponent.add(myUseWrapperButton, constraints);
     myComponent.add(myUseLocalDistributionButton, constraints);
 
+    myComponent.add(myUseAutoImportBox, fillLineConstraints);
+    
     myComponent.add(myGradleHomeLabel, pathLabelConstraints);
-    myComponent.add(myGradleHomePathField, pathConstraints);
+    myComponent.add(myGradleHomePathField, fillLineConstraints);
 
     myComponent.add(myServiceDirectoryLabel, pathLabelConstraints);
-    myComponent.add(myServiceDirectoryPathField, pathConstraints);
+    myComponent.add(myServiceDirectoryPathField, fillLineConstraints);
 
     myComponent.add(Box.createVerticalGlue(), new GridBag().weightx(1).weighty(1).fillCell().coverLine());
   }
@@ -404,6 +413,10 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     {
       return true;
     }
+
+    if (myUseAutoImportBox.isSelected() != settings.isUseAutoImport()) {
+      return true;
+    }
     
     return false;
   }
@@ -428,7 +441,8 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
                                                myServiceDirectoryPathField.getText());
     
     boolean preferLocalToWrapper = myUseLocalDistributionButton.isSelected();
-    myHelper.applySettings(linkedProjectPath, gradleHomePath, preferLocalToWrapper, serviceDirPath, myProject);
+    boolean useAutoImport = myUseAutoImportBox.isSelected();
+    myHelper.applySettings(linkedProjectPath, gradleHomePath, preferLocalToWrapper, useAutoImport, serviceDirPath, myProject);
 
     Project defaultProject = myHelper.getDefaultProject();
     if (myProject != defaultProject) {
@@ -563,6 +577,8 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
       myServiceDirectoryPathField.setText(serviceDirectoryPath);
       useColorForPath(PathColor.NORMAL, myServiceDirectoryPathField);
     }
+    
+    myUseAutoImportBox.setSelected(settings.isUseAutoImport());
   }
 
   private static void useColorForPath(@NotNull PathColor color, @NotNull TextFieldWithBrowseButton pathControl) {
@@ -674,6 +690,7 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     void applySettings(@Nullable String linkedProjectPath,
                        @Nullable String gradleHomePath,
                        boolean preferLocalInstallationToWrapper,
+                       boolean useAutoImport,
                        @Nullable String serviceDirectoryPath,
                        @NotNull Project project);
     
@@ -719,10 +736,13 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     public void applySettings(@Nullable String linkedProjectPath,
                               @Nullable String gradleHomePath,
                               boolean preferLocalInstallationToWrapper,
+                              boolean useAutoImport,
                               @Nullable String serviceDirectoryPath,
                               @NotNull Project project)
     {
-      GradleSettings.applySettings(linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, serviceDirectoryPath, project); 
+      GradleSettings.applySettings(
+        linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, useAutoImport, serviceDirectoryPath, project
+      ); 
     }
 
     @Override
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleSettings.java
index f1d035208fe7..87757134f1a7 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleSettings.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleSettings.java
@@ -44,6 +44,7 @@ public class GradleSettings implements PersistentStateComponent<GradleSettings>
   private String  myGradleHome;
   private String  myServiceDirectoryPath;
   private boolean myPreferLocalInstallationToWrapper;
+  private boolean myUseAutoImport = true; // Turned on by default.
 
   @Override
   public GradleSettings getState() {
@@ -139,9 +140,27 @@ public class GradleSettings implements PersistentStateComponent<GradleSettings>
     }
   }
 
+  public boolean isUseAutoImport() {
+    return myUseAutoImport;
+  }
+
+  public void setUseAutoImport(boolean useAutoImport) {
+    myUseAutoImport = useAutoImport;
+  }
+
+  public static void applyUseAutoImport(boolean useAutoImport, @NotNull Project project) {
+    final GradleSettings settings = getInstance(project);
+    final boolean oldValue = settings.isUseAutoImport();
+    if (oldValue != useAutoImport) {
+      settings.setUseAutoImport(useAutoImport);
+      project.getMessageBus().syncPublisher(GradleConfigNotifier.TOPIC).onUseAutoImportChange(oldValue, useAutoImport);
+    }
+  }
+
   public static void applySettings(@Nullable String linkedProjectPath,
                                    @Nullable String gradleHomePath,
                                    boolean preferLocalInstallationToWrapper,
+                                   boolean useAutoImport,
                                    @Nullable String serviceDirectoryPath,
                                    @NotNull Project project)
   {
@@ -151,6 +170,7 @@ public class GradleSettings implements PersistentStateComponent<GradleSettings>
       applyLinkedProjectPath(linkedProjectPath, project);
       applyGradleHome(gradleHomePath, project);
       applyPreferLocalInstallationToWrapper(preferLocalInstallationToWrapper, project);
+      applyUseAutoImport(useAutoImport, project);
       applyServiceDirectoryPath(serviceDirectoryPath, project);
     }
     finally {
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleToolWindowPanel.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleToolWindowPanel.java
index 0cea2ab76522..8adb91f3a252 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleToolWindowPanel.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleToolWindowPanel.java
@@ -95,7 +95,8 @@ public abstract class GradleToolWindowPanel extends SimpleToolWindowPanel {
       @Override public void onPreferLocalGradleDistributionToWrapperChange(boolean preferLocalToWrapper) { refreshAll(); }
       @Override public void onGradleHomeChange(@Nullable String oldPath, @Nullable String newPath) { refreshAll(); }
       @Override public void onServiceDirectoryPathChange(@Nullable String oldPath, @Nullable String newPath) { refreshAll(); }
-      
+      @Override public void onUseAutoImportChange(boolean oldValue, boolean newValue) { refreshAll(); }
+
       private void refreshAll() {
         if (myInBulk) {
           myRefresh = true;
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
index 6bbfb66b7769..22c403502f88 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
@@ -2,6 +2,7 @@ package org.jetbrains.plugins.gradle.manage;
 
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTable;
@@ -179,4 +180,24 @@ public class GradleDependencyManager {
       });
     }
   }
+
+  public void setScope(@NotNull final DependencyScope scope, @NotNull final ExportableOrderEntry dependency, boolean synchronous) {
+    Project project = dependency.getOwnerModule().getProject();
+    GradleUtil.executeProjectChangeAction(project, dependency, synchronous, new Runnable() {
+      @Override
+      public void run() {
+        dependency.setScope(scope); 
+      }
+    });
+  }
+
+  public void setExported(final boolean exported, @NotNull final ExportableOrderEntry dependency, boolean synchronous) {
+    Project project = dependency.getOwnerModule().getProject();
+    GradleUtil.executeProjectChangeAction(project, dependency, synchronous, new Runnable() {
+      @Override
+      public void run() {
+        dependency.setExported(exported);
+      }
+    });
+  }
 }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleEntityManageHelper.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleEntityManageHelper.java
index 022240590c5f..c9a8838b2a39 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleEntityManageHelper.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleEntityManageHelper.java
@@ -23,7 +23,23 @@ import com.intellij.openapi.roots.ModuleOrderEntry;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.util.containers.ContainerUtilRt;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.gradle.autoimport.*;
+import org.jetbrains.plugins.gradle.diff.AbstractGradleConflictingPropertyChange;
+import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChange;
+import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChangeVisitor;
+import org.jetbrains.plugins.gradle.diff.contentroot.GradleContentRootPresenceChange;
+import org.jetbrains.plugins.gradle.diff.dependency.GradleDependencyExportedChange;
+import org.jetbrains.plugins.gradle.diff.dependency.GradleDependencyScopeChange;
+import org.jetbrains.plugins.gradle.diff.dependency.GradleLibraryDependencyPresenceChange;
+import org.jetbrains.plugins.gradle.diff.dependency.GradleModuleDependencyPresenceChange;
+import org.jetbrains.plugins.gradle.diff.library.GradleJarPresenceChange;
+import org.jetbrains.plugins.gradle.diff.library.GradleOutdatedLibraryVersionChange;
+import org.jetbrains.plugins.gradle.diff.module.GradleModulePresenceChange;
+import org.jetbrains.plugins.gradle.diff.project.GradleLanguageLevelChange;
+import org.jetbrains.plugins.gradle.diff.project.GradleProjectRenameChange;
 import org.jetbrains.plugins.gradle.model.gradle.*;
+import org.jetbrains.plugins.gradle.model.id.*;
 import org.jetbrains.plugins.gradle.model.intellij.IdeEntityVisitor;
 import org.jetbrains.plugins.gradle.model.intellij.ModuleAwareContentRoot;
 import org.jetbrains.plugins.gradle.sync.GradleProjectStructureHelper;
@@ -42,6 +58,7 @@ public class GradleEntityManageHelper {
 
   @NotNull private final Project                      myProject;
   @NotNull private final GradleProjectStructureHelper myProjectStructureHelper;
+  @NotNull private final GradleProjectManager         myProjectManager;
   @NotNull private final GradleModuleManager          myModuleManager;
   @NotNull private final GradleLibraryManager         myLibraryManager;
   @NotNull private final GradleJarManager             myJarManager;
@@ -50,6 +67,7 @@ public class GradleEntityManageHelper {
 
   public GradleEntityManageHelper(@NotNull Project project,
                                   @NotNull GradleProjectStructureHelper helper,
+                                  @NotNull GradleProjectManager projectManager,
                                   @NotNull GradleModuleManager moduleManager,
                                   @NotNull GradleLibraryManager libraryManager,
                                   @NotNull GradleJarManager jarManager,
@@ -58,6 +76,7 @@ public class GradleEntityManageHelper {
   {
     myProject = project;
     myProjectStructureHelper = helper;
+    myProjectManager = projectManager;
     myModuleManager = moduleManager;
     myLibraryManager = libraryManager;
     myJarManager = jarManager;
@@ -72,20 +91,36 @@ public class GradleEntityManageHelper {
     final Set<GradleJar> jars = ContainerUtilRt.newHashSet();
     final Map<GradleModule, Collection<GradleDependency>> dependencies = ContainerUtilRt.newHashMap();
     GradleEntityVisitor visitor = new GradleEntityVisitor() {
-      @Override public void visit(@NotNull GradleProject project) { }
-      @Override public void visit(@NotNull GradleModule module) { modules.add(module); }
-      @Override public void visit(@NotNull GradleLibrary library) { libraries.add(library); }
-      @Override public void visit(@NotNull GradleJar jar) { jars.add(jar); }
-      @Override public void visit(@NotNull GradleModuleDependency dependency) { addDependency(dependency); }
-      @Override public void visit(@NotNull GradleLibraryDependency dependency) { addDependency(dependency); }
-      @Override public void visit(@NotNull GradleCompositeLibraryDependency dependency) { }
-      @Override public void visit(@NotNull GradleContentRoot contentRoot) {
+      @Override
+      public void visit(@NotNull GradleProject project) { }
+
+      @Override
+      public void visit(@NotNull GradleModule module) { modules.add(module); }
+
+      @Override
+      public void visit(@NotNull GradleLibrary library) { libraries.add(library); }
+
+      @Override
+      public void visit(@NotNull GradleJar jar) { jars.add(jar); }
+
+      @Override
+      public void visit(@NotNull GradleModuleDependency dependency) { addDependency(dependency); }
+
+      @Override
+      public void visit(@NotNull GradleLibraryDependency dependency) { addDependency(dependency); }
+
+      @Override
+      public void visit(@NotNull GradleCompositeLibraryDependency dependency) { }
+
+      @Override
+      public void visit(@NotNull GradleContentRoot contentRoot) {
         Collection<GradleContentRoot> roots = contentRoots.get(contentRoot.getOwnerModule());
         if (roots == null) {
           contentRoots.put(contentRoot.getOwnerModule(), roots = ContainerUtilRt.<GradleContentRoot>newHashSet());
         }
         roots.add(contentRoot);
       }
+
       private void addDependency(@NotNull GradleDependency dependency) {
         Collection<GradleDependency> d = dependencies.get(dependency.getOwnerModule());
         if (d == null) {
@@ -144,4 +179,269 @@ public class GradleEntityManageHelper {
     myDependencyManager.removeDependencies(dependencies, synchronous);
     myModuleManager.removeModules(modules, synchronous);
   }
+
+  /**
+   * Tries to eliminate all target changes (namely, all given except those which correspond 'changes to preserve') 
+   * 
+   * @param changesToEliminate  changes to eliminate
+   * @param changesToPreserve   changes to preserve
+   * @param synchronous         defines if the processing should be synchronous
+   * @return                    non-processed changes
+   */
+  public Set<GradleProjectStructureChange> eliminateChange(@NotNull Collection<GradleProjectStructureChange> changesToEliminate,
+                                                           @NotNull final Set<GradleUserProjectChange> changesToPreserve,
+                                                           boolean synchronous)
+  {
+    EliminateChangesContext context = new EliminateChangesContext(
+      myProjectStructureHelper, changesToPreserve, myProjectManager, myDependencyManager, synchronous
+    );
+    for (GradleProjectStructureChange change : changesToEliminate) {
+      change.invite(context.visitor);
+    }
+    
+    removeEntities(context.entitiesToRemove, synchronous);
+    importEntities(context.entitiesToImport, synchronous);
+    return context.nonProcessedChanges;
+  }
+
+  private static void processProjectRenameChange(@NotNull GradleProjectRenameChange change, @NotNull EliminateChangesContext context) {
+    context.projectManager.renameProject(change.getGradleValue(), context.projectStructureHelper.getProject(), context.synchronous);
+  }
+  
+  private static void processLanguageLevelChange(@NotNull GradleLanguageLevelChange change, @NotNull EliminateChangesContext context) {
+    context.projectManager.setLanguageLevel(change.getGradleValue(), context.projectStructureHelper.getProject(), context.synchronous);
+  }
+  
+  private static void processModulePresenceChange(@NotNull GradleModulePresenceChange change, @NotNull EliminateChangesContext context) {
+    GradleModuleId id = change.getGradleEntity();
+    if (id == null) {
+      // IDE-local change.
+      id = change.getIdeEntity();
+      assert id != null;
+      Module module = context.projectStructureHelper.findIdeModule(id.getModuleName());
+      if (module != null && !context.changesToPreserve.contains(new GradleAddModuleUserChange(id.getModuleName()))) {
+        context.entitiesToRemove.add(module);
+        return;
+      }
+    }
+    else {
+      GradleModule module = context.projectStructureHelper.findGradleModule(id.getModuleName());
+      if (module != null && !context.changesToPreserve.contains(new GradleRemoveModuleUserChange(id.getModuleName()))) {
+        context.entitiesToImport.add(module);
+        return;
+      }
+    }
+    context.nonProcessedChanges.add(change);
+  }
+
+  private static void processContentRootPresenceChange(@NotNull GradleContentRootPresenceChange change,
+                                                       @NotNull EliminateChangesContext context)
+  {
+    GradleContentRootId id = change.getGradleEntity();
+    if (id == null) {
+      // IDE-local change.
+      id = change.getIdeEntity();
+      assert id != null;
+      ModuleAwareContentRoot root = context.projectStructureHelper.findIdeContentRoot(id);
+      if (root != null) {
+        context.entitiesToRemove.add(root);
+        return;
+      }
+    }
+    else {
+      GradleContentRoot root = context.projectStructureHelper.findGradleContentRoot(id);
+      if (root != null) {
+        context.entitiesToImport.add(root);
+        return;
+      }
+    }
+    context.nonProcessedChanges.add(change);
+  }
+  
+  private static void processLibraryDependencyPresenceChange(@NotNull GradleLibraryDependencyPresenceChange change,
+                                                             @NotNull EliminateChangesContext context)
+  {
+    GradleLibraryDependencyId id = change.getGradleEntity();
+    if (id == null) {
+      // IDE-local change.
+      id = change.getIdeEntity();
+      assert id != null;
+      LibraryOrderEntry dependency = context.projectStructureHelper.findIdeLibraryDependency(id);
+      GradleAddLibraryDependencyUserChange c = new GradleAddLibraryDependencyUserChange(id.getOwnerModuleName(), id.getDependencyName());
+      if (dependency != null && !context.changesToPreserve.contains(c)) {
+        context.entitiesToRemove.add(dependency);
+        return;
+      }
+    }
+    else {
+      GradleLibraryDependency dependency = context.projectStructureHelper.findGradleLibraryDependency(id);
+      GradleRemoveLibraryDependencyUserChange c
+        = new GradleRemoveLibraryDependencyUserChange(id.getOwnerModuleName(), id.getDependencyName());
+      if (dependency != null && !context.changesToPreserve.contains(c)) {
+        context.entitiesToImport.add(dependency);
+        return;
+      }
+    }
+    context.nonProcessedChanges.add(change);
+  }
+  
+  private static void processJarPresenceChange(@NotNull GradleJarPresenceChange change, @NotNull EliminateChangesContext context) {
+    GradleJarId id = change.getGradleEntity();
+    if (id == null) {
+      // IDE-local change.
+      id = change.getIdeEntity();
+      assert id != null;
+      GradleJar jar = context.projectStructureHelper.findIdeJar(id);
+      if (jar != null) {
+        context.entitiesToRemove.add(jar);
+        return;
+      }
+    }
+    else {
+      GradleLibrary library = context.projectStructureHelper.findGradleLibrary(id.getLibraryId());
+      if (library != null) {
+        context.entitiesToImport.add(new GradleJar(id.getPath(), id.getLibraryPathType(), null, library));
+        return;
+      }
+    }
+    context.nonProcessedChanges.add(change);
+  }
+
+  private static void processModuleDependencyPresenceChange(@NotNull GradleModuleDependencyPresenceChange change,
+                                                            @NotNull EliminateChangesContext context)
+  {
+    GradleModuleDependencyId id = change.getGradleEntity();
+    if (id == null) {
+      // IDE-local change.
+      id = change.getIdeEntity();
+      assert id != null;
+      ModuleOrderEntry dependency = context.projectStructureHelper.findIdeModuleDependency(id);
+      GradleAddModuleDependencyUserChange c = new GradleAddModuleDependencyUserChange(id.getOwnerModuleName(), id.getDependencyName());
+      if (dependency != null && !context.changesToPreserve.contains(c)) {
+        context.entitiesToRemove.add(dependency);
+        return;
+      }
+    }
+    else {
+      GradleModuleDependency dependency = context.projectStructureHelper.findGradleModuleDependency(id);
+      GradleRemoveModuleDependencyUserChange c
+        = new GradleRemoveModuleDependencyUserChange(id.getOwnerModuleName(), id.getDependencyName());
+      if (dependency != null && !context.changesToPreserve.contains(c)) {
+        context.entitiesToImport.add(dependency);
+        return;
+      }
+    }
+    context.nonProcessedChanges.add(change);
+  }
+  
+  private static void processDependencyScopeChange(@NotNull GradleDependencyScopeChange change, @NotNull EliminateChangesContext context) {
+    ExportableOrderEntry dependency = findDependency(change, context);
+    if (dependency != null) {
+      context.dependencyManager.setScope(change.getGradleValue(), dependency, context.synchronous);
+    }
+  }
+
+  private static void processDependencyExportedStatusChange(@NotNull GradleDependencyExportedChange change,
+                                                            @NotNull EliminateChangesContext context)
+  {
+    ExportableOrderEntry dependency = findDependency(change, context);
+    if (dependency != null) {
+      context.dependencyManager.setExported(change.getGradleValue(), dependency, context.synchronous);
+    }
+  }
+
+  @Nullable
+  private static ExportableOrderEntry findDependency(@NotNull AbstractGradleConflictingPropertyChange<?> change,
+                                                     @NotNull EliminateChangesContext context)
+  {
+    GradleEntityId id = change.getEntityId();
+    ExportableOrderEntry dependency = null;
+    if (id instanceof GradleLibraryDependencyId) {
+      dependency = context.projectStructureHelper.findIdeLibraryDependency((GradleLibraryDependencyId)id);
+    }
+    else if (id instanceof GradleModuleDependencyId) {
+      dependency = context.projectStructureHelper.findIdeModuleDependency((GradleModuleDependencyId)id);
+    }
+    else {
+      context.nonProcessedChanges.add(change);
+    }
+    return dependency;
+  }
+  
+  private static class EliminateChangesContext {
+    @NotNull final Set<Object>                       entitiesToRemove    = ContainerUtilRt.newHashSet();
+    @NotNull final Set<GradleEntity>                 entitiesToImport    = ContainerUtilRt.newHashSet();
+    @NotNull final Set<GradleProjectStructureChange> nonProcessedChanges = ContainerUtilRt.newHashSet();
+    @NotNull final Set<GradleUserProjectChange>      changesToPreserve   = ContainerUtilRt.newHashSet();
+
+    @NotNull final GradleProjectManager    projectManager;
+    @NotNull final GradleDependencyManager dependencyManager;
+    final          boolean                 synchronous;
+
+    @NotNull GradleProjectStructureChangeVisitor visitor = new GradleProjectStructureChangeVisitor() {
+      @Override
+      public void visit(@NotNull GradleProjectRenameChange change) {
+        processProjectRenameChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleLanguageLevelChange change) {
+        processLanguageLevelChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleModulePresenceChange change) {
+        processModulePresenceChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleContentRootPresenceChange change) {
+        processContentRootPresenceChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleLibraryDependencyPresenceChange change) {
+        processLibraryDependencyPresenceChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleJarPresenceChange change) {
+        processJarPresenceChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleOutdatedLibraryVersionChange change) {
+      }
+
+      @Override
+      public void visit(@NotNull GradleModuleDependencyPresenceChange change) {
+        processModuleDependencyPresenceChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleDependencyScopeChange change) {
+        processDependencyScopeChange(change, EliminateChangesContext.this);
+      }
+
+      @Override
+      public void visit(@NotNull GradleDependencyExportedChange change) {
+        processDependencyExportedStatusChange(change, EliminateChangesContext.this);
+      }
+    };
+
+    @NotNull final GradleProjectStructureHelper projectStructureHelper;
+
+    EliminateChangesContext(@NotNull GradleProjectStructureHelper projectStructureHelper,
+                            @NotNull Set<GradleUserProjectChange> changesToPreserve,
+                            @NotNull GradleProjectManager projectManager,
+                            @NotNull GradleDependencyManager dependencyManager,
+                            boolean synchronous)
+    {
+      this.projectStructureHelper = projectStructureHelper;
+      this.changesToPreserve.addAll(changesToPreserve);
+      this.projectManager = projectManager;
+      this.dependencyManager = dependencyManager;
+      this.synchronous = synchronous;
+    }
+  }
 }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleModuleManager.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleModuleManager.java
index db493961986a..c60b6e2d1e19 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleModuleManager.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleModuleManager.java
@@ -7,6 +7,8 @@ import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.StdModuleTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.Alarm;
 import com.intellij.util.containers.hash.HashMap;
 import com.intellij.util.ui.UIUtil;
@@ -16,6 +18,7 @@ import org.jetbrains.plugins.gradle.util.GradleLog;
 import org.jetbrains.plugins.gradle.util.GradleUtil;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
@@ -61,7 +64,7 @@ public class GradleModuleManager {
     Runnable task = new Runnable() {
       @Override
       public void run() {
-        removeExistingModulesConfigs(modules);
+        removeExistingModulesConfigs(modules, project);
         Application application = ApplicationManager.getApplication();
         final Map<GradleModule, Module> moduleMappings = new HashMap<GradleModule, Module>();
         application.runWriteAction(new Runnable() {
@@ -130,18 +133,28 @@ public class GradleModuleManager {
     }
   }
 
-  private static void removeExistingModulesConfigs(@NotNull Collection<? extends  GradleModule> modules) {
-    for (GradleModule module : modules) {
-      // Remove existing '*.iml' file if necessary.
-      final String moduleFilePath = module.getModuleFilePath();
-      File file = new File(moduleFilePath);
-      if (file.isFile()) {
-        boolean success = file.delete();
-        if (!success) {
-          GradleLog.LOG.warn("Can't remove existing module file at '" + moduleFilePath + "'");
-        }
-      }
+  private void removeExistingModulesConfigs(@NotNull final Collection<? extends  GradleModule> modules, @NotNull Project project) {
+    if (modules.isEmpty()) {
+      return;
     }
+    GradleUtil.executeProjectChangeAction(project, modules, true, new Runnable() {
+      @Override
+      public void run() {
+        LocalFileSystem fileSystem = LocalFileSystem.getInstance();
+        for (GradleModule module : modules) {
+          // Remove existing '*.iml' file if necessary.
+          VirtualFile file = fileSystem.refreshAndFindFileByPath(module.getModuleFilePath());
+          if (file != null) {
+            try {
+              file.delete(this);
+            }
+            catch (IOException e) {
+              GradleLog.LOG.warn("Can't remove existing module file at '" + module.getModuleFilePath() + "'");
+            }
+          }
+        } 
+      }
+    });
   }
 
   @SuppressWarnings("MethodMayBeStatic")
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectImportBuilder.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectImportBuilder.java
index c2790b9eae6e..947e02c2d1a4 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectImportBuilder.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectImportBuilder.java
@@ -141,6 +141,7 @@ public class GradleProjectImportBuilder extends ProjectImportBuilder<GradleProje
         GradleSettings.applyLinkedProjectPath(myConfigurable.getLinkedProjectPath(), project);
         GradleSettings.applyPreferLocalInstallationToWrapper(myConfigurable.isPreferLocalInstallationToWrapper(), project);
         GradleSettings.applyGradleHome(myConfigurable.getGradleHomePath(), project);
+        GradleSettings.applyUseAutoImport(myConfigurable.isUseAutoImport(), project);
         // Reset gradle home for default project.
         GradleSettings.applyLinkedProjectPath(null, ProjectManager.getInstance().getDefaultProject());
 
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectManager.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectManager.java
new file mode 100644
index 000000000000..6f4fb8d40856
--- /dev/null
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleProjectManager.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.gradle.manage;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.ex.ProjectEx;
+import com.intellij.openapi.roots.LanguageLevelProjectExtension;
+import com.intellij.pom.java.LanguageLevel;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.gradle.util.GradleUtil;
+
+/**
+ * @author Denis Zhdanov
+ * @since 2/21/13 2:40 PM
+ */
+public class GradleProjectManager {
+
+  public void renameProject(@NotNull final String newName, @NotNull final Project project, boolean synchronous) {
+    if (!(project instanceof ProjectEx) || newName.equals(project.getName())) {
+      return;
+    }
+    GradleUtil.executeProjectChangeAction(project, project, synchronous, new Runnable() {
+      @Override
+      public void run() {
+        ((ProjectEx)project).setProjectName(newName);
+      }
+    });
+  }
+
+  public void setLanguageLevel(@NotNull final LanguageLevel languageLevel, @NotNull Project project, boolean synchronous) {
+    final LanguageLevelProjectExtension languageLevelExtension = LanguageLevelProjectExtension.getInstance(project);
+    if (languageLevel == languageLevelExtension.getLanguageLevel()) {
+      return;
+    }
+    GradleUtil.executeProjectChangeAction(project, project, synchronous, new Runnable() {
+      @Override
+      public void run() {
+        languageLevelExtension.setLanguageLevel(languageLevel); 
+      }
+    });
+  }
+}
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesDetector.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesDetector.java
index 925cf67cf9f0..52e905cefb74 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesDetector.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesDetector.java
@@ -11,6 +11,7 @@ import com.intellij.util.Alarm;
 import com.intellij.util.messages.MessageBusConnection;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.gradle.autoimport.GradleAutoImporter;
 import org.jetbrains.plugins.gradle.autoimport.GradleUserProjectChangesCalculator;
 import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChange;
 import org.jetbrains.plugins.gradle.manage.GradleProjectEntityChangeListener;
@@ -43,14 +44,17 @@ public class GradleProjectStructureChangesDetector implements GradleProjectStruc
   @NotNull private final GradleProjectStructureChangesModel myChangesModel;
   @NotNull private final Project                            myProject;
   @NotNull private final GradleUserProjectChangesCalculator myUserProjectChangesCalculator;
+  @NotNull private final GradleAutoImporter                 myAutoImporter;
 
   public GradleProjectStructureChangesDetector(@NotNull Project project,
                                                @NotNull GradleProjectStructureChangesModel model,
-                                               @NotNull GradleUserProjectChangesCalculator calculator)
+                                               @NotNull GradleUserProjectChangesCalculator calculator,
+                                               @NotNull GradleAutoImporter importer)
   {
     myProject = project;
     myChangesModel = model;
     myUserProjectChangesCalculator = calculator;
+    myAutoImporter = importer;
     myChangesModel.addListener(this);
     subscribeToGradleImport(project);
     subscribeToRootChanges(project);
@@ -69,7 +73,6 @@ public class GradleProjectStructureChangesDetector implements GradleProjectStruc
         if (myImportCounter.decrementAndGet() <= 0) {
 
           myUserProjectChangesCalculator.updateCurrentProjectState();
-          myUserProjectChangesCalculator.filterOutdatedChanges();
 
           GradleProject project = myChangesModel.getGradleProject();
           if (project != null) {
@@ -81,9 +84,9 @@ public class GradleProjectStructureChangesDetector implements GradleProjectStruc
           rebuildTreeModel();
         }
       }
-    });    
+    });
   }
-  
+
   private void subscribeToRootChanges(@NotNull Project project) {
     project.getMessageBus().connect(project).subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
       @Override
@@ -98,7 +101,7 @@ public class GradleProjectStructureChangesDetector implements GradleProjectStruc
   private void rebuildTreeModel() {
     final GradleProjectStructureTreeModel treeModel = GradleUtil.getProjectStructureTreeModel(myProject);
     if (treeModel != null) {
-      treeModel.rebuild();
+      treeModel.rebuild(myAutoImporter.isInProgress());
     }
   }
 
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesModel.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesModel.java
index 0153868cca29..b2ac0b2b8b05 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesModel.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureChangesModel.java
@@ -5,6 +5,7 @@ import com.intellij.util.containers.ContainerUtilRt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
+import org.jetbrains.plugins.gradle.autoimport.GradleAutoImporter;
 import org.jetbrains.plugins.gradle.config.PlatformFacade;
 import org.jetbrains.plugins.gradle.diff.GradleChangesCalculationContext;
 import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChange;
@@ -47,6 +48,7 @@ public class GradleProjectStructureChangesModel {
                                             @NotNull PlatformFacade platformFacade,
                                             @NotNull GradleLibraryPathTypeMapper mapper,
                                             @NotNull GradleDuplicateLibrariesPreProcessor duplicateLibrariesPreProcessor,
+                                            @NotNull GradleAutoImporter autoImporter,
                                             @NotNull GradleMovedJarsPostProcessor movedJarsPostProcessor,
                                             @NotNull GradleOutdatedLibraryVersionPostProcessor changedLibraryVersionPostProcessor)
   {
@@ -55,6 +57,7 @@ public class GradleProjectStructureChangesModel {
     myPlatformFacade = platformFacade;
     myLibraryPathTypeMapper = mapper;
     myPreProcessors.add(duplicateLibrariesPreProcessor);
+    myPostProcessors.add(autoImporter);
     myPostProcessors.add(movedJarsPostProcessor);
     myPostProcessors.add(changedLibraryVersionPostProcessor);
   }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureHelper.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureHelper.java
index 9ec3d669a70b..f294e16eea16 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureHelper.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureHelper.java
@@ -323,6 +323,11 @@ public class GradleProjectStructureHelper {
     return null;
   }
 
+  @Nullable
+  public GradleModuleDependency findGradleModuleDependency(@NotNull GradleModuleDependencyId id) {
+    return findGradleModuleDependency(id.getOwnerModuleName(), id.getDependencyName());
+  }
+  
   @Nullable
   public GradleModuleDependency findGradleModuleDependency(@NotNull final String ownerModuleName,
                                                            @NotNull final String dependencyModuleName)
@@ -345,6 +350,11 @@ public class GradleProjectStructureHelper {
     }
     return ref.get();
   }
+
+  @Nullable
+  public ModuleOrderEntry findIdeModuleDependency(@NotNull final GradleModuleDependencyId id) {
+    return findIdeModuleDependency(id.getOwnerModuleName(), id.getDependencyName());
+  }
   
   @Nullable
   public ModuleOrderEntry findIdeModuleDependency(@NotNull final GradleModuleDependency gradleDependency) {
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureTreeModel.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureTreeModel.java
index 1e5685a78197..7bba4434d174 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureTreeModel.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/sync/GradleProjectStructureTreeModel.java
@@ -158,6 +158,10 @@ public class GradleProjectStructureTreeModel extends DefaultTreeModel {
   }
 
   public void rebuild() {
+    rebuild(false);
+  }
+  
+  public void rebuild(boolean onIdeProjectStructureChange) {
     myModuleDependencies.clear();
     myModules.clear();
 
@@ -224,7 +228,7 @@ public class GradleProjectStructureTreeModel extends DefaultTreeModel {
 
     GradleProject project = myChangesModel.getGradleProject();
     if (project != null) {
-      GradleChangesCalculationContext context = myChangesModel.getCurrentChangesContext(project, false);
+      GradleChangesCalculationContext context = myChangesModel.getCurrentChangesContext(project, onIdeProjectStructureChange);
       processChanges(Collections.<GradleProjectStructureChange>emptyList(), context.getCurrentChanges());
       filterNodes(root);
     }

From 8de5f33a7d7319ae2d475818192bc5d8c64b8d65 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Thu, 21 Feb 2013 17:52:32 +0400
Subject: [PATCH 007/354] cli-parser.jar added to jps distribution

---
 build/scripts/layouts.gant | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build/scripts/layouts.gant b/build/scripts/layouts.gant
index cdb7688d8cea..cb202f3dc436 100644
--- a/build/scripts/layouts.gant
+++ b/build/scripts/layouts.gant
@@ -606,6 +606,7 @@ def layout_jps(String home, String target) {
       include(name: "asm4-all.jar")
       include(name: "nanoxml-*.jar")
       include(name: "protobuf-*.jar")
+      include(name: "cli-parser-*.jar")
       include(name: "optimizedFileManager.jar")
       include(name: "log4j.jar")
       include(name: "jgoodies-forms.jar")

From ac91b3616956fa61bba3934b2de5d7b2456a716f Mon Sep 17 00:00:00 2001
From: Alexander Kirillin <angus@jetbrains.com>
Date: Thu, 21 Feb 2013 17:59:45 +0400
Subject: [PATCH 008/354] OC-6207 Remove unused receiver and parameter
 variables in Inline Method

---
 .../psi/impl/PsiToDocumentSynchronizer.java   | 31 ++++++++++++-------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/psi/impl/PsiToDocumentSynchronizer.java b/platform/lang-impl/src/com/intellij/psi/impl/PsiToDocumentSynchronizer.java
index 9cf95dcd0367..02b2300f9409 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/PsiToDocumentSynchronizer.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/PsiToDocumentSynchronizer.java
@@ -26,6 +26,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.impl.source.tree.ForeignLeafPsiElement;
 import com.intellij.util.messages.MessageBus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -105,22 +106,26 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
 
   @Override
   public void childAdded(@NotNull final PsiTreeChangeEvent event) {
-    doSync(event, false, new DocSyncAction() {
-      @Override
-      public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
-        insertString(document, event.getOffset(), event.getChild().getText());
-      }
+    if (!(event.getChild() instanceof ForeignLeafPsiElement)) {
+      doSync(event, false, new DocSyncAction() {
+        @Override
+        public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
+          insertString(document, event.getOffset(), event.getChild().getText());
+        }
     });
+    }
   }
 
   @Override
   public void childRemoved(@NotNull final PsiTreeChangeEvent event) {
-    doSync(event, false, new DocSyncAction() {
-      @Override
-      public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
-        deleteString(document, event.getOffset(), event.getOffset() + event.getOldLength());
-      }
-    });
+    if (!(event.getChild() instanceof ForeignLeafPsiElement)) {
+      doSync(event, false, new DocSyncAction() {
+        @Override
+        public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
+          deleteString(document, event.getOffset(), event.getOffset() + event.getOldLength());
+        }
+      });
+    }
   }
 
   @Override
@@ -128,7 +133,9 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
     doSync(event, false, new DocSyncAction() {
       @Override
       public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
-        replaceString(document, event.getOffset(), event.getOffset() + event.getOldLength(), event.getNewChild().getText());
+        int oldLength = event.getOldChild() instanceof ForeignLeafPsiElement ? 0 : event.getOldLength();
+        String newText = event.getNewChild() instanceof ForeignLeafPsiElement ? "" : event.getNewChild().getText();
+        replaceString(document, event.getOffset(), event.getOffset() + oldLength, newText);
       }
     });
   }

From f27f0ef1dcab9e47ecb0da39f7bca7a3cc5edf55 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Thu, 21 Feb 2013 18:09:43 +0400
Subject: [PATCH 009/354] Gradle: show project refresh update messages at the
 main progress indicator text (make them visible for the indicators located at
 the status bar)

---
 plugins/gradle/resources/i18n/GradleBundle.properties          | 3 ++-
 .../org/jetbrains/plugins/gradle/task/AbstractGradleTask.java  | 3 ++-
 .../src/org/jetbrains/plugins/gradle/util/GradleUtil.java      | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/plugins/gradle/resources/i18n/GradleBundle.properties b/plugins/gradle/resources/i18n/GradleBundle.properties
index f99b6cd319ad..78a97c1100be 100644
--- a/plugins/gradle/resources/i18n/GradleBundle.properties
+++ b/plugins/gradle/resources/i18n/GradleBundle.properties
@@ -56,7 +56,8 @@ gradle.import.text.error.file.module.compile.output.location=Module compile outp
 gradle.import.text.error.file.module.test.output.location=Module test output location is undefined
 
 gradle.sync.title.tab=project structure changes
-gradle.sync.progress.text=Refreshing Gradle project
+gradle.sync.progress.initial.text=Refreshing Gradle project
+gradle.sync.progress.update.text=Gradle: {0}
 gradle.sync.change.type.gradle=Gradle local entities
 gradle.sync.change.type.intellij=IntelliJ IDEA local entities
 gradle.sync.change.type.conflict=Entities with conflicting setup
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/task/AbstractGradleTask.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/task/AbstractGradleTask.java
index 6be6f4448fc2..c2e5af793d9c 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/task/AbstractGradleTask.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/task/AbstractGradleTask.java
@@ -12,6 +12,7 @@ import org.jetbrains.plugins.gradle.notification.GradleTaskNotificationListener;
 import org.jetbrains.plugins.gradle.notification.GradleTaskNotificationListenerAdapter;
 import org.jetbrains.plugins.gradle.remote.GradleApiFacade;
 import org.jetbrains.plugins.gradle.remote.GradleApiFacadeManager;
+import org.jetbrains.plugins.gradle.util.GradleBundle;
 
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -86,7 +87,7 @@ public abstract class AbstractGradleTask implements GradleTask {
     execute(new GradleTaskNotificationListenerAdapter() {
       @Override
       public void onStatusChange(@NotNull GradleTaskNotificationEvent event) {
-        indicator.setText2(event.getDescription());
+        indicator.setText(GradleBundle.message("gradle.sync.progress.update.text", event.getDescription()));
       }
     });
   }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
index d7d213910033..a4302558a359 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
@@ -322,7 +322,7 @@ public class GradleUtil {
           });
         }
         else {
-          ProgressManager.getInstance().run(new Task.Backgroundable(project, GradleBundle.message("gradle.sync.progress.text")) {
+          ProgressManager.getInstance().run(new Task.Backgroundable(project, GradleBundle.message("gradle.sync.progress.initial.text")) {
             @Override
             public void run(@NotNull ProgressIndicator indicator) {
               task.execute(indicator);

From e869310a923c94838c8c095c11ab4c586e01bb81 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 13:27:29 +0100
Subject: [PATCH 010/354] ambiguous method call: choose one method if both are
 from the same hierarchy as the actual problem is there (IDEA-101529)

---
 .../JavaMethodsConflictResolver.java                |  4 +++-
 .../pck/AmbiguousMethodCall.java                    | 13 +++++++++++++
 .../codeInsight/daemon/AdvHighlightingJdk7Test.java |  4 ++++
 3 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMethodsFromSameClassAccess/pck/AmbiguousMethodCall.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
index 5a67a6a61f20..fdf4f44b08cc 100644
--- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
+++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
@@ -550,7 +550,9 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     }
     if (isMoreSpecific == null) {
       if (!JavaVersionService.getInstance().isAtLeast(myArgumentsList, JavaSdkVersion.JDK_1_7) ||
-          !MethodSignatureUtil.areParametersErasureEqual(method1, method2)) {
+          !MethodSignatureUtil.areParametersErasureEqual(method1, method2) ||
+           InheritanceUtil.isInheritorOrSelf(class1, class2, true) ||
+           InheritanceUtil.isInheritorOrSelf(class2, class1, true)) {
         if (typeParameters1.length < typeParameters2.length) return Specifics.FIRST;
         if (typeParameters1.length > typeParameters2.length) return Specifics.SECOND;
       }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMethodsFromSameClassAccess/pck/AmbiguousMethodCall.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMethodsFromSameClassAccess/pck/AmbiguousMethodCall.java
new file mode 100644
index 000000000000..7b468c8e1042
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/ambiguousMethodsFromSameClassAccess/pck/AmbiguousMethodCall.java
@@ -0,0 +1,13 @@
+package pck;
+
+class A {
+    public void bar(I a, Class<Long> any) {
+        System.out.println(a.with(any));
+    }
+
+    interface I {
+        <error descr="'with(Class<T>)' clashes with 'with(Class<Long>)'; both methods have same erasure"><T> T with(Class<T> aClass)</error>;
+        long with(Class<Long> aClass);
+    }
+}
+
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java
index 92c4d7c351b2..85f4fcaa4697 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/AdvHighlightingJdk7Test.java
@@ -191,4 +191,8 @@ public class AdvHighlightingJdk7Test extends DaemonAnalyzerTestCase {
   public void testAmbiguousIDEA87672() throws Exception {
     doTestAmbiguous();
   }
+
+  public void testAmbiguousMethodsFromSameClassAccess() throws Exception {
+    doTestAmbiguous();
+  }
 }

From 985efd2362202ee58850fc1ef9e20152cd65e00c Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 15:04:54 +0100
Subject: [PATCH 011/354] more specific method should be chosen before static
 access is checked (IDEA-101480)

---
 .../JavaMethodsConflictResolver.java          | 20 ++++++++++++-------
 ...nceMemberNotAccessibleInStaticContext.java | 11 ++++++++++
 .../daemon/LightAdvHighlightingJdk7Test.java  |  1 +
 .../psi/resolve/ResolveMethodTest.java        |  2 +-
 4 files changed, 26 insertions(+), 8 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/InstanceMemberNotAccessibleInStaticContext.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
index fdf4f44b08cc..7501526a3d69 100644
--- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
+++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
@@ -67,7 +67,7 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     checkSameSignatures(conflicts);
     if (conflicts.size() == 1) return conflicts.get(0);
 
-    checkAccessLevels(conflicts);
+    checkAccessStaticLevels(conflicts, true);
     if (conflicts.size() == 1) return conflicts.get(0);
 
     checkParametersNumber(conflicts, myActualParameterTypes.length, false);
@@ -89,6 +89,9 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     checkPrimitiveVarargs(conflicts, myActualParameterTypes.length);
     if (conflicts.size() == 1) return conflicts.get(0);
 
+    checkAccessStaticLevels(conflicts, false);
+    if (conflicts.size() == 1) return conflicts.get(0);
+
     THashSet<CandidateInfo> uniques = new THashSet<CandidateInfo>(conflicts);
     if (uniques.size() == 1) return uniques.iterator().next();
     return null;
@@ -158,7 +161,7 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     }
   }
 
-  private static void checkAccessLevels(List<CandidateInfo> conflicts) {
+  private static void checkAccessStaticLevels(List<CandidateInfo> conflicts, boolean checkAccessible) {
     int conflictsCount = conflicts.size();
 
     int maxCheckLevel = -1;
@@ -166,7 +169,7 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     int index = 0;
     for (final CandidateInfo conflict : conflicts) {
       final MethodCandidateInfo method = (MethodCandidateInfo)conflict;
-      final int level = getCheckLevel(method);
+      final int level = checkAccessible ? getCheckAccessLevel(method) : getCheckStaticLevel(method);
       checkLevels[index++] = level;
       maxCheckLevel = Math.max(maxCheckLevel, level);
     }
@@ -379,11 +382,14 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
     return level;
   }
 
-  private static int getCheckLevel(MethodCandidateInfo method){
-    boolean visible = method.isAccessible();// && !method.myStaticProblem;
+  private static int getCheckAccessLevel(MethodCandidateInfo method){
+    boolean visible = method.isAccessible();
+    return visible ? 1 : 0;
+  }
+
+  private static int getCheckStaticLevel(MethodCandidateInfo method){
     boolean available = method.isStaticsScopeCorrect();
-    return (visible ? 1 : 0) << 2 |
-           (available ? 1 : 0) << 1 |
+    return (available ? 1 : 0) << 1 |
            (method.getCurrentFileResolveScope() instanceof PsiImportStaticStatement ? 0 : 1);
   }
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/InstanceMemberNotAccessibleInStaticContext.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/InstanceMemberNotAccessibleInStaticContext.java
new file mode 100644
index 000000000000..aa827bcea454
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/InstanceMemberNotAccessibleInStaticContext.java
@@ -0,0 +1,11 @@
+class Foo {
+    public void foo() {}
+
+    public static void foo(String... s){}
+}
+
+class A {
+    {
+        Foo.<error descr="Non-static method 'foo()' cannot be referenced from a static context">foo</error>();
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/LightAdvHighlightingJdk7Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/LightAdvHighlightingJdk7Test.java
index 53710582edd5..4b90e72ccf81 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/LightAdvHighlightingJdk7Test.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/LightAdvHighlightingJdk7Test.java
@@ -166,4 +166,5 @@ public class LightAdvHighlightingJdk7Test extends LightDaemonAnalyzerTestCase {
   public void testWrongArgsAndUnknownTypeParams() throws Exception { doTest(false, false); }
   public void testAmbiguousMethodCallIDEA97983() throws Exception { doTest(false, false); }
   public void testAmbiguousMethodCallIDEA100314() throws Exception { doTest(false, false); }
+  public void testInstanceMemberNotAccessibleInStaticContext() throws Exception { doTest(false, false); }
 }
diff --git a/java/java-tests/testSrc/com/intellij/psi/resolve/ResolveMethodTest.java b/java/java-tests/testSrc/com/intellij/psi/resolve/ResolveMethodTest.java
index 274483b52350..b45903c9f17f 100644
--- a/java/java-tests/testSrc/com/intellij/psi/resolve/ResolveMethodTest.java
+++ b/java/java-tests/testSrc/com/intellij/psi/resolve/ResolveMethodTest.java
@@ -204,7 +204,7 @@ public class ResolveMethodTest extends ResolveTestCase {
     PsiElement target = resolve();
     assertTrue(target instanceof PsiMethod);
     PsiMethod method = (PsiMethod) target;
-    assertEquals(1, method.getParameterList().getParametersCount());
+    assertEquals(0, method.getParameterList().getParametersCount());
   }
 
   public void testClone() throws Exception{

From 6f89c562da03d22933da617365b48630c37dbf5d Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 15:20:35 +0100
Subject: [PATCH 012/354] plugin repository: forbid 2 || threads reading
 available plugins; disable refresh action when plugins are loading
 (IDEA-99902)

---
 .../com/intellij/ide/plugins/PluginManagerMain.java    | 10 ++++++++--
 .../src/com/intellij/ide/plugins/RepositoryHelper.java |  4 +---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java b/platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java
index c5ca4c758e58..05f0fd3921c9 100644
--- a/platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java
+++ b/platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java
@@ -104,6 +104,7 @@ public abstract class PluginManagerMain implements Disposable {
   protected final MyPluginsFilter myFilter = new MyPluginsFilter();
   protected PluginManagerUISettings myUISettings;
   private boolean myDisposed = false;
+  private boolean myBusy = false;
 
   public PluginManagerMain(
     PluginManagerUISettings uiSettings) {
@@ -249,13 +250,12 @@ public abstract class PluginManagerMain implements Disposable {
       public void finished() {
         UIUtil.invokeLaterIfNeeded(new Runnable() {
           public void run() {
+            setDownloadStatus(false);
             if (list != null && errorMessages.isEmpty()) {
               modifyPluginsList(list);
               propagateUpdates(list);
-              setDownloadStatus(false);
             }
             else if (!errorMessages.isEmpty()) {
-              setDownloadStatus(false);
               if (0 == Messages.showOkCancelDialog(
                 IdeBundle.message("error.list.of.plugins.was.not.loaded", StringUtil.join(errorMessages, ", ")),
                 IdeBundle.message("title.plugins"),
@@ -273,6 +273,7 @@ public abstract class PluginManagerMain implements Disposable {
 
   protected void setDownloadStatus(boolean status) {
     pluginTable.setPaintBusy(status);
+    myBusy = status;
   }
 
   protected void loadAvailablePlugins() {
@@ -565,5 +566,10 @@ public abstract class PluginManagerMain implements Disposable {
       loadAvailablePlugins();
       myFilter.setFilter("");
     }
+
+    @Override
+    public void update(AnActionEvent e) {
+      e.getPresentation().setEnabled(!myBusy);
+    }
   }
 }
diff --git a/platform/platform-impl/src/com/intellij/ide/plugins/RepositoryHelper.java b/platform/platform-impl/src/com/intellij/ide/plugins/RepositoryHelper.java
index d1ee94fb6c44..fa5ee62d5fb5 100644
--- a/platform/platform-impl/src/com/intellij/ide/plugins/RepositoryHelper.java
+++ b/platform/platform-impl/src/com/intellij/ide/plugins/RepositoryHelper.java
@@ -38,8 +38,6 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
-import java.net.URL;
-import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.zip.GZIPInputStream;
 
@@ -127,7 +125,7 @@ public class RepositoryHelper {
     return temp;
   }
 
-  private static void readPluginsStream(InputStream is, RepositoryContentHandler handler, ProgressIndicator indicator, final String file)
+  private synchronized static void readPluginsStream(InputStream is, RepositoryContentHandler handler, ProgressIndicator indicator, final String file)
     throws SAXException, IOException, ParserConfigurationException, ProcessCanceledException {
     File temp = createLocalPluginsDescriptions(file);
     SAXParser parser = SAXParserFactory.newInstance().newSAXParser();

From d87c046eadc9c853e4a6e85fdf6872f47a1f5d7e Mon Sep 17 00:00:00 2001
From: "andrey.zaytsev" <andrey.zaytsev@jetbrains.com>
Date: Wed, 20 Feb 2013 22:21:45 +0400
Subject: [PATCH 013/354] IDEA-101456 Throwable at
 com.intellij.openapi.application.impl.ApplicationImpl.assertWriteAccessAllowed.
 also remove temporary breakpoint after hit when debug process stops

---
 .../debugger/ui/breakpoints/Breakpoint.java   | 37 +++++++++++++------
 .../xdebugger/impl/XDebugSessionImpl.java     | 32 ++++++++++------
 2 files changed, 45 insertions(+), 24 deletions(-)

diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
index 58b1917b57a1..3d694e1dd28f 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
@@ -249,21 +249,34 @@ public abstract class Breakpoint extends FilteredRequestor implements ClassPrepa
       }
     }
     if (REMOVE_AFTER_HIT) {
-      debugProcess.addDebugProcessListener(new DebugProcessAdapter() {
-        @Override
-        public void resumed(SuspendContext suspendContext) {
-          DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {
-            @Override
-            public void run() {
-              DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().removeBreakpoint(Breakpoint.this);
-            }
-          });
-          debugProcess.removeDebugProcessListener(this);
-        }
-      });
+      handleTemporaryBreakpointHit(debugProcess);
     }
   }
 
+  private void handleTemporaryBreakpointHit(final DebugProcessImpl debugProcess) {
+    debugProcess.addDebugProcessListener(new DebugProcessAdapter() {
+      @Override
+      public void resumed(SuspendContext suspendContext) {
+        removeBreakpoint();
+      }
+
+      @Override
+      public void processDetached(DebugProcess process, boolean closedByUser) {
+        removeBreakpoint();
+      }
+
+      private void removeBreakpoint() {
+        DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {
+          @Override
+          public void run() {
+            DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().removeBreakpoint(Breakpoint.this);
+          }
+        });
+        debugProcess.removeDebugProcessListener(this);
+      }
+    });
+  }
+
   public final void updateUI() {
     updateUI(EmptyRunnable.getInstance());
   }
diff --git a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebugSessionImpl.java b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebugSessionImpl.java
index 41fab55e3864..4df444162c32 100644
--- a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebugSessionImpl.java
+++ b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebugSessionImpl.java
@@ -588,22 +588,30 @@ public class XDebugSessionImpl implements XDebugSession {
     positionReached(suspendContext);
 
     if (breakpoint instanceof XLineBreakpoint<?> && ((XLineBreakpoint)breakpoint).isTemporary()) {
-      addSessionListener(new XDebugSessionAdapter() {
-        @Override
-        public void sessionResumed() {
-          DebuggerUIUtil.invokeOnEventDispatch(new Runnable() {
-            @Override
-            public void run() {
-              XDebuggerManager.getInstance(myProject).getBreakpointManager().removeBreakpoint(breakpoint);
-            }
-          });
-          removeSessionListener(this);
-        }
-      });
+      handleTemporaryBreakpointHit(breakpoint);
     }
     return true;
   }
 
+  private void handleTemporaryBreakpointHit(final XBreakpoint<?> breakpoint) {
+    addSessionListener(new XDebugSessionAdapter() {
+      private void removeBreakpoint() {
+        XDebuggerUtil.getInstance().removeBreakpoint(myProject, breakpoint);
+        removeSessionListener(this);
+      }
+
+      @Override
+      public void sessionResumed() {
+        removeBreakpoint();
+      }
+
+      @Override
+      public void sessionStopped() {
+        removeBreakpoint();
+      }
+    });
+  }
+
   private void processDependencies(final XBreakpoint<?> breakpoint) {
     XDependentBreakpointManager dependentBreakpointManager = myDebuggerManager.getBreakpointManager().getDependentBreakpointManager();
     if (!dependentBreakpointManager.isMasterOrSlave(breakpoint)) return;

From c1b2ff060e8d58d6bdd6d7c128e118254843dfbb Mon Sep 17 00:00:00 2001
From: Oleg Sukhodolsky <oleg.sukhodolsky@jetbrains.com>
Date: Thu, 21 Feb 2013 19:14:03 +0400
Subject: [PATCH 014/354] RUBY-13089: ruby specific options moved to ruby
 extansion for Darcula

---
 colorSchemes/src/colorSchemes/Darcula.xml | 186 ----------------------
 1 file changed, 186 deletions(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 8c5f570f8a5c..5546bed865e6 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -1143,192 +1143,6 @@
         <option name="FONT_TYPE" value="1" />
       </value>
     </option>
-    <option name="RUBY_ATTR_ACCESSOR_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_ATTR_READER_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_ATTR_WRITER_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_BACK_REF">
-      <value>
-        <option name="FOREGROUND" value="0" />
-        <option name="FONT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_BAD_CHARACTER">
-      <value>
-        <option name="EFFECT_COLOR" value="ff0000" />
-        <option name="EFFECT_TYPE" value="2" />
-      </value>
-    </option>
-    <option name="RUBY_COMMA">
-      <value />
-    </option>
-    <option name="RUBY_COMMENT">
-      <value>
-        <option name="FOREGROUND" value="bc9458" />
-        <option name="FONT_TYPE" value="2" />
-      </value>
-    </option>
-    <option name="RUBY_CONSTANT">
-      <value>
-        <option name="FOREGROUND" value="da4939" />
-      </value>
-    </option>
-    <option name="RUBY_CONSTANT_DEF_ID">
-      <value>
-        <option name="FOREGROUND" value="9f0e9b" />
-        <option name="FONT_TYPE" value="3" />
-      </value>
-    </option>
-    <option name="RUBY_CVAR">
-      <value>
-        <option name="FOREGROUND" value="d0d0ff" />
-      </value>
-    </option>
-    <option name="RUBY_ESCAPE_SEQUENCE">
-      <value>
-        <option name="FOREGROUND" value="519f50" />
-      </value>
-    </option>
-    <option name="RUBY_EXPR_IN_STRING">
-      <value />
-    </option>
-    <option name="RUBY_GVAR">
-      <value>
-        <option name="FOREGROUND" value="d0d0ff" />
-      </value>
-    </option>
-    <option name="RUBY_HASH_ASSOC">
-      <value />
-    </option>
-    <option name="RUBY_HEREDOC_CONTENT">
-      <value>
-        <option name="FOREGROUND" value="a5c261" />
-      </value>
-    </option>
-    <option name="RUBY_HEREDOC_ID">
-      <value>
-        <option name="FOREGROUND" value="a5c261" />
-        <option name="EFFECT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_IMPORT_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_INTERPOLATED_STRING">
-      <value>
-        <option name="FOREGROUND" value="52a12e" />
-        <option name="FONT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_INVALID_ESCAPE_SEQUENCE">
-      <value>
-        <option name="FOREGROUND" value="519f50" />
-        <option name="EFFECT_COLOR" value="ff0000" />
-        <option name="EFFECT_TYPE" value="2" />
-      </value>
-    </option>
-    <option name="RUBY_IVAR">
-      <value>
-        <option name="FOREGROUND" value="d0d0ff" />
-      </value>
-    </option>
-    <option name="RUBY_KEYWORD">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_LINE_CONTINUATION">
-      <value />
-    </option>
-    <option name="RUBY_LOCAL_VAR_ID">
-      <value>
-        <option name="FOREGROUND" value="78b4" />
-      </value>
-    </option>
-    <option name="RUBY_METHOD_NAME">
-      <value>
-        <option name="FOREGROUND" value="ffc66d" />
-      </value>
-    </option>
-    <option name="RUBY_NTH_REF">
-      <value>
-        <option name="FOREGROUND" value="d0d0ff" />
-      </value>
-    </option>
-    <option name="RUBY_NUMBER">
-      <value>
-        <option name="FOREGROUND" value="a5c261" />
-        <option name="EFFECT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_OPERATION_SIGN">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_PARAMETER_ID">
-      <value>
-        <option name="FOREGROUND" value="c37522" />
-        <option name="EFFECT_TYPE" value="2" />
-      </value>
-    </option>
-    <option name="RUBY_PRIVATE_CALL">
-      <value>
-        <option name="FONT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_PROTECTED_CALL">
-      <value>
-        <option name="FONT_TYPE" value="1" />
-      </value>
-    </option>
-    <option name="RUBY_PUBLIC_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-      </value>
-    </option>
-    <option name="RUBY_REGEXP">
-      <value>
-        <option name="FOREGROUND" value="a5c261" />
-      </value>
-    </option>
-    <option name="RUBY_REQUIRE_ARG_CALL">
-      <value>
-        <option name="FONT_TYPE" value="3" />
-      </value>
-    </option>
-    <option name="RUBY_REQUIRE_CALL">
-      <value>
-        <option name="FOREGROUND" value="cc7833" />
-        <option name="EFFECT_TYPE" value="2" />
-      </value>
-    </option>
-    <option name="RUBY_SEMICOLON">
-      <value />
-    </option>
-    <option name="RUBY_SPECIFIC_CALL">
-      <value>
-        <option name="FOREGROUND" value="da4939" />
-      </value>
-    </option>
-    <option name="RUBY_SYMBOL">
-      <value>
-        <option name="FOREGROUND" value="6e9cbe" />
-      </value>
-    </option>
     <option name="SASS_ATTRIBUTE">
       <value>
         <option name="FOREGROUND" value="6d9cbe" />

From c0979014ac73de08c8d635de6bd9476ef6527f4d Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 21 Feb 2013 19:19:28 +0400
Subject: [PATCH 015/354] hide splash when welcome screen is shown

---
 .../com/intellij/idea/IdeaApplication.java    | 34 +++++++------------
 1 file changed, 13 insertions(+), 21 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java b/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
index 8ebdb3980038..5dd2c2f5a3b9 100644
--- a/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
+++ b/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
@@ -37,10 +37,7 @@ import com.intellij.openapi.updateSettings.impl.UpdateChecker;
 import com.intellij.openapi.updateSettings.impl.UpdateSettings;
 import com.intellij.openapi.util.*;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.wm.IdeFrame;
 import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.WindowManagerListener;
-import com.intellij.openapi.wm.ex.WindowManagerEx;
 import com.intellij.openapi.wm.impl.WindowManagerImpl;
 import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeFrame;
 import com.intellij.ui.Splash;
@@ -83,6 +80,7 @@ public class IdeaApplication {
     }
     else {
       patchSystem();
+      new JFrame(); // this peer will prevent shutting down our application
       Splash splash = null;
       if (myArgs.length == 0) {
         myStarter = getStarter();
@@ -276,22 +274,7 @@ public class IdeaApplication {
       // application components. So it is proper to perform replacement only here.
       ApplicationEx app = ApplicationManagerEx.getApplicationEx();
       // app.setupIdeQueue(IdeEventQueue.getInstance());
-      final WindowManagerEx windowManager = (WindowManagerEx)WindowManager.getInstance();
-      WindowManagerListener splashDisposer = new WindowManagerListener() {
-        @Override
-        public void frameCreated(IdeFrame frame) {
-          if (mySplash != null) {
-            mySplash.dispose();
-            mySplash = null; // Allow GC collect the splash window
-          }
-          windowManager.removeListener(this);
-        }
-
-        @Override
-        public void beforeFrameReleased(IdeFrame frame) {}
-      };
-
-      windowManager.addListener(splashDisposer);
+      WindowManagerImpl windowManager = (WindowManagerImpl)WindowManager.getInstance();
 
       try {
         IdeEventQueue.getInstance().setWindowManager(windowManager);
@@ -304,10 +287,9 @@ public class IdeaApplication {
         if (!willOpenProject.get()) {
           WelcomeFrame.showNow();
           lifecyclePublisher.welcomeScreenDisplayed();
-          splashDisposer.frameCreated(null);
         }
         else {
-          ((WindowManagerImpl)windowManager).showFrame();
+          windowManager.showFrame();
         }
       }
       catch (PluginException e) {
@@ -317,6 +299,16 @@ public class IdeaApplication {
         System.exit(-1);
       }
 
+      app.invokeLater(new Runnable() {
+        @Override
+        public void run() {
+          if (mySplash != null) {
+            mySplash.dispose();
+            mySplash = null; // Allow GC collect the splash window
+          }
+        }
+      }, ModalityState.NON_MODAL);
+
       app.invokeLater(new Runnable() {
         @Override
         public void run() {

From 61daa2a6b8c83ed0becd3dc14ebcdbeb7e79562e Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Thu, 21 Feb 2013 19:25:45 +0400
Subject: [PATCH 016/354] fix unnesessary ExecutionException logging

---
 .../src/com/intellij/execution/rmi/RemoteProcessSupport.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/execution/rmi/RemoteProcessSupport.java b/platform/lang-impl/src/com/intellij/execution/rmi/RemoteProcessSupport.java
index 46b07b690437..9706bdeedb9f 100644
--- a/platform/lang-impl/src/com/intellij/execution/rmi/RemoteProcessSupport.java
+++ b/platform/lang-impl/src/com/intellij/execution/rmi/RemoteProcessSupport.java
@@ -171,7 +171,7 @@ public abstract class RemoteProcessSupport<Target, EntryPoint, Parameters> {
       processHandler = result.getProcessHandler();
     }
     catch (Exception e) {
-      dropProcessInfo(key, ExceptionUtil.getUserStackTrace(e, LOG), processHandler);
+      dropProcessInfo(key, e instanceof ExecutionException? e.getMessage() : ExceptionUtil.getUserStackTrace(e, LOG), processHandler);
       return;
     }
     processHandler.addProcessListener(getProcessListener(key));

From d0f4f864d877509ad2fd1f3dcea974124d753a1c Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Thu, 21 Feb 2013 19:42:34 +0400
Subject: [PATCH 017/354] IDEA-98409 groovy create function generates return
 statement for def return value

---
 .../plugins/groovy/intentions/base/IntentionUtils.java    | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/intentions/base/IntentionUtils.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/intentions/base/IntentionUtils.java
index 53637fb6999f..8e3ae1edd75b 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/intentions/base/IntentionUtils.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/intentions/base/IntentionUtils.java
@@ -34,6 +34,7 @@ import org.jetbrains.plugins.groovy.annotator.intentions.QuickfixUtil;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrStatement;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
 import org.jetbrains.plugins.groovy.lang.psi.expectedTypes.TypeConstraint;
 import org.jetbrains.plugins.groovy.template.expressions.ChooseTypeExpression;
 import org.jetbrains.plugins.groovy.template.expressions.ParameterNameExpression;
@@ -134,7 +135,14 @@ public class IntentionUtils {
             }
             if (method != null) {
               try {
+                final boolean hasNoReturnType = method.getReturnTypeElement() == null && method instanceof GrMethod;
+                if (hasNoReturnType) {
+                  ((GrMethod)method).setReturnType(PsiType.VOID);
+                }
                 CreateFromUsageUtils.setupMethodBody(method);
+                if (hasNoReturnType) {
+                  ((GrMethod)method).setReturnType(null);
+                }
               }
               catch (IncorrectOperationException e) {
                 LOG.error(e);

From 9ab097b11dd658e90ef2c19f8bbbfe91c4cdc74f Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 17:36:44 +0100
Subject: [PATCH 018/354] lambda: skip parenthesis exprs

---
 .../psi/impl/source/resolve/GraphInferencePolicy.java      | 2 +-
 .../ProcessCandidateParameterTypeInferencePolicy.java      | 5 +++++
 .../psi/impl/source/resolve/PsiResolveHelperImpl.java      | 7 ++++++-
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
index 76342896b897..a6593a730008 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
@@ -99,7 +99,7 @@ public class GraphInferencePolicy extends ProcessCandidateParameterTypeInference
   }
 
   public static void forget(PsiElement parent) {
-    if (parent instanceof PsiCallExpression) {
+    if (parent instanceof PsiExpression) {
       final PsiElement gParent = parent.getParent();
       if (gParent instanceof PsiExpressionList) {
         final PsiElement ggParent = gParent.getParent();
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
index b67bb8242e58..e9045a8c9c15 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
@@ -43,6 +43,11 @@ public class ProcessCandidateParameterTypeInferencePolicy extends DefaultParamet
                                                                           PsiCallExpression contextCall,
                                                                           PsiTypeParameter typeParameter) {
     PsiExpression[] expressions = expressionList.getExpressions();
+    PsiElement parent = innerMethodCall.getParent();
+    while (parent instanceof PsiParenthesizedExpression) {
+      innerMethodCall = (PsiExpression)parent;
+      parent = parent.getParent();
+    }
     int i = ArrayUtil.find(expressions, innerMethodCall);
     if (i < 0) return null;
     PsiMethod owner = (PsiMethod)typeParameter.getOwner();
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
index 48a87d8e6b3e..5af0d2dae5b3 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
@@ -1073,7 +1073,12 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
       expectedType = ((PsiTypeCastExpression)parent).getType();
     } else if (parent instanceof PsiConditionalExpression) {
       if (PsiUtil.isLanguageLevel8OrHigher(parent)) {
-        return inferMethodTypeParameterFromParent(parent.getParent(), (PsiExpression)parent, typeParameter, substitutor, policy);
+        try {
+          return inferMethodTypeParameterFromParent(PsiUtil.skipParenthesizedExprUp(parent.getParent()), (PsiExpression)parent, typeParameter, substitutor, policy);
+        }
+        finally {
+          GraphInferencePolicy.forget(parent);
+        }
       }
     }
 

From c4c870f1c5c73c1f93c93603df7c0c19e4e1bd46 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 18:23:52 +0100
Subject: [PATCH 019/354] skip spaces after incomplete members only

---
 .../psi/impl/JavaPsiImplementationHelperImpl.java         | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/java/java-impl/src/com/intellij/psi/impl/JavaPsiImplementationHelperImpl.java b/java/java-impl/src/com/intellij/psi/impl/JavaPsiImplementationHelperImpl.java
index b8389a2f4fa9..0e98a3873bb8 100644
--- a/java/java-impl/src/com/intellij/psi/impl/JavaPsiImplementationHelperImpl.java
+++ b/java/java-impl/src/com/intellij/psi/impl/JavaPsiImplementationHelperImpl.java
@@ -195,11 +195,15 @@ public class JavaPsiImplementationHelperImpl extends JavaPsiImplementationHelper
     if (anchor != null && anchor != aClass) {
       anchor = anchor.getNextSibling();
       while (anchor instanceof PsiJavaToken && (anchor.getText().equals(",") || anchor.getText().equals(";"))) {
+        final boolean afterComma = anchor.getText().equals(",");
         anchor = anchor.getNextSibling();
+        if (afterComma) {
+          newAnchor = skipWhitespaces(aClass, anchor);
+          if (newAnchor != null) return newAnchor;
+        }
       }
       if (anchor != null) {
-        newAnchor = skipWhitespaces(aClass, anchor);
-        return newAnchor != null ? newAnchor : anchor;
+        return anchor;
       }
     }
 

From 442bc82b5711f7cc51acaa7a018c34d6698e89fa Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <denzhdanov@gmail.com>
Date: Thu, 21 Feb 2013 19:51:10 +0400
Subject: [PATCH 020/354] IDEA-95898 Gradle based projects should offer
 Auto-Import as Maven projects do

GradleJarManager correctly performs bulk 'import jars' operation by separating jars by library
---
 .../gradle/manage/GradleJarManager.java       | 80 +++++++++++--------
 1 file changed, 45 insertions(+), 35 deletions(-)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleJarManager.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleJarManager.java
index 6488c84b828d..29107de686e4 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleJarManager.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleJarManager.java
@@ -59,50 +59,60 @@ public class GradleJarManager {
     if (jars.isEmpty()) {
       return;
     }
+    final Map<GradleLibraryId, List<GradleJar>> jarsByLibraries = ContainerUtilRt.newHashMap();
+    for (GradleJar jar : jars) {
+      List<GradleJar> list = jarsByLibraries.get(jar.getLibraryId());
+      if (list == null) {
+        jarsByLibraries.put(jar.getLibraryId(), list = ContainerUtilRt.newArrayList());
+      }
+      list.add(jar);
+    }
     GradleUtil.executeProjectChangeAction(project, jars, synchronous, new Runnable() {
       @Override
       public void run() {
-        LibraryTable table = myPlatformFacade.getProjectLibraryTable(project);
-        Library library = table.getLibraryByName(jars.iterator().next().getLibraryId().getLibraryName());
-        if (library == null) {
-          return;
-        }
-        Library.ModifiableModel model = library.getModifiableModel();
-        try {
-          LocalFileSystem fileSystem = LocalFileSystem.getInstance();
-          for (GradleJar jar : jars) {
-            OrderRootType ideJarType = myLibraryPathTypeMapper.map(jar.getPathType());
-            for (VirtualFile file : model.getFiles(ideJarType)) {
-              if (jar.getPath().equals(GradleUtil.getLocalFileSystemPath(file))) {
-                return;
+        for (Map.Entry<GradleLibraryId, List<GradleJar>> entry : jarsByLibraries.entrySet()) {
+          LibraryTable table = myPlatformFacade.getProjectLibraryTable(project);
+          Library library = table.getLibraryByName(entry.getKey().getLibraryName());
+          if (library == null) {
+            return;
+          }
+          Library.ModifiableModel model = library.getModifiableModel();
+          try {
+            LocalFileSystem fileSystem = LocalFileSystem.getInstance();
+            for (GradleJar jar : entry.getValue()) {
+              OrderRootType ideJarType = myLibraryPathTypeMapper.map(jar.getPathType());
+              for (VirtualFile file : model.getFiles(ideJarType)) {
+                if (jar.getPath().equals(GradleUtil.getLocalFileSystemPath(file))) {
+                  return;
+                }
               }
-            }
 
-            File jarFile = new File(jar.getPath());
-            VirtualFile virtualFile = fileSystem.refreshAndFindFileByIoFile(jarFile);
-            if (virtualFile == null) {
-              GradleLog.LOG.warn(
-                String.format("Can't find a jar of the library '%s' at path '%s'", jar.getLibraryId().getLibraryName(), jar.getPath())
-              );
-              return;
-            }
-            if (virtualFile.isDirectory()) {
-              model.addRoot(virtualFile, ideJarType);
-            }
-            else {
-              VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(virtualFile);
-              if (jarRoot == null) {
-                GradleLog.LOG.warn(String.format(
-                  "Can't parse contents of the jar file at path '%s' for the library '%s''", jar.getPath(), library.getName()
-                ));
+              File jarFile = new File(jar.getPath());
+              VirtualFile virtualFile = fileSystem.refreshAndFindFileByIoFile(jarFile);
+              if (virtualFile == null) {
+                GradleLog.LOG.warn(
+                  String.format("Can't find a jar of the library '%s' at path '%s'", jar.getLibraryId().getLibraryName(), jar.getPath())
+                );
                 return;
               }
-              model.addRoot(jarRoot, ideJarType);
+              if (virtualFile.isDirectory()) {
+                model.addRoot(virtualFile, ideJarType);
+              }
+              else {
+                VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(virtualFile);
+                if (jarRoot == null) {
+                  GradleLog.LOG.warn(String.format(
+                    "Can't parse contents of the jar file at path '%s' for the library '%s''", jar.getPath(), library.getName()
+                  ));
+                  return;
+                }
+                model.addRoot(jarRoot, ideJarType);
+              }
             }
           }
-        }
-        finally {
-          model.commit();
+          finally {
+            model.commit();
+          }
         }
       }
     });

From 7883a2f5223348104fb68cf0379214233fdf352a Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <denzhdanov@gmail.com>
Date: Thu, 21 Feb 2013 22:26:23 +0400
Subject: [PATCH 021/354] IDEA-95898 Gradle based projects should offer
 Auto-Import as Maven projects do

Revive gradle tests after auto-import introduction (change service dependencies and api)
---
 .../config/GradleConfigurableTest.groovy      |   2 +-
 .../GradleLocalNodeManageHelperTest.groovy    | 158 ------------------
 .../GradleMovedJarsPostProcessorTest.groovy   |   1 +
 .../gradle/testutil/AbstractGradleTest.groovy |  14 ++
 4 files changed, 16 insertions(+), 159 deletions(-)
 delete mode 100644 plugins/gradle/testSources/org/jetbrains/plugins/gradle/manage/GradleLocalNodeManageHelperTest.groovy

diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/config/GradleConfigurableTest.groovy b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/config/GradleConfigurableTest.groovy
index 529f9ac0c0db..a96bcc5f771d 100644
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/config/GradleConfigurableTest.groovy
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/config/GradleConfigurableTest.groovy
@@ -29,7 +29,7 @@ public class GradleConfigurableTest {
   void setUp() {
     helper = [
       getSettings : { settings[it] },
-      applySettings: {linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, serviceDirectoryPath, project -> },
+      applySettings: {linkedProjectPath, gradleHomePath, preferLocalInstallationToWrapper, autoImport, serviceDirectoryPath, project -> },
       applyPreferLocalInstallationToWrapper: { preferLocalInstallationToWrapper, project -> },
       getGradleHome: { new File(VALID_GRADLE_HOME) },
       getDefaultProject: { defaultProject },
diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/manage/GradleLocalNodeManageHelperTest.groovy b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/manage/GradleLocalNodeManageHelperTest.groovy
deleted file mode 100644
index 349c43e54fc3..000000000000
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/manage/GradleLocalNodeManageHelperTest.groovy
+++ /dev/null
@@ -1,158 +0,0 @@
-package org.jetbrains.plugins.gradle.manage;
-
-
-import org.jetbrains.plugins.gradle.model.id.GradleEntityIdMapper
-import org.jetbrains.plugins.gradle.testutil.AbstractGradleTest
-import org.junit.Before
-import org.junit.Test
-import org.picocontainer.MutablePicoContainer
-
-import javax.swing.tree.TreeNode
-
-import static org.junit.Assert.fail
-
-/**
- * @author Denis Zhdanov
- * @since 02/10/2012
- */
-public class GradleLocalNodeManageHelperTest extends AbstractGradleTest {
-
-  private GradleLocalNodeManageHelper myHelper
-
-  @Before
-  public void setUp() {
-    super.setUp();
-    clearChangePostProcessors()
-  }
-  
-  @Override
-  protected void configureContainer(MutablePicoContainer container) {
-    container.registerComponentImplementation(GradleLocalNodeManageHelper)
-    container.registerComponentImplementation(GradleModuleManager)
-    container.registerComponentImplementation(GradleContentRootManager)
-  }
-
-  @Test
-  public void "library dependency causes module and library to be transitively imported as well"() {
-    doTest {
-      project {
-        module('module1', transitive: true, order: 0) { // Mark that the module should be imported
-          dependencies {
-            library('lib1', initial: true, order: 2) // Mark that this node should be given as initially selected
-            library('lib2') // No mark here. Means that the node should not be imported
-        } }
-        library('lib1', transitive: true, order: 1) // Mark that the library should be imported
-        library('lib2') // No mark here. Means that the library should not be imported
-    } }
-  }
-
-  @Test
-  public void "module import covers content root"() {
-    doTest {
-      project {
-        module('module1', initial: true, order: 0) {
-          contentRoot('1', transitive: true, order: 1)
-    } } }
-  }
-
-  @SuppressWarnings("GroovyAssignabilityCheck")
-  private def doTest(Closure c) {
-    myHelper = container.getComponentInstance(GradleLocalNodeManageHelper)
-    def compositeBuilder = new CompositeProjectBuilder(gradleBuilder: gradle, intellijBuilder: intellij)
-    c.delegate = compositeBuilder
-    c.call()
-    init()
-    myHelper
-    def nodes = collectNodes(treeModel.root as TreeNode, compositeBuilder.initial)
-    def expectedEntities = compositeBuilder.expected.sort{ a, b -> a[0].compareTo(b[0]) }.collect { it[1] }
-    def actual = myHelper.deriveEntitiesToImport(nodes)
-    if (expectedEntities == actual) {
-      return
-    }
-    fail("""\
-Mismatched 'import nodes with dependencies'.
-  Initial: ${out -> nodes.each { out << "\n    * $it"}}
-  Expected ordered graph: ${out -> expectedEntities.eachWithIndex { val, i -> out << "\n    $i) $val"}}
-  Actual ordered grapth: ${out -> actual.eachWithIndex { val, i -> out << "\n    $i) $val"}}
-""")
-  }
-
-  private List collectNodes(TreeNode node, initial, holder = []) {
-    if (initial.contains(node.descriptor.element)) {
-      holder << node
-    }
-    for (child in node) {
-      collectNodes(child, initial, holder)
-    }
-    holder
-  }
-  
-  class CompositeProjectBuilder extends BuilderSupport {
-    
-    def gradleBuilder
-    def intellijBuilder
-    def initial = [].toSet()
-    def expected = []
-    private def gradleLocalRoot
-    private def gradleStack = new Stack()
-    private def intellijStack = new Stack()
-
-    @Override
-    protected void setParent(Object parent, Object child) { }
-
-    @Override
-    protected void nodeCompleted(Object parent, Object node) {
-      gradleStack.pop()
-      if (node == gradleLocalRoot) {
-        gradleLocalRoot = null
-      }
-      if (!gradleLocalRoot && !intellijStack.isEmpty()) {
-        intellijStack.pop()
-      }
-    }
-
-    @Override
-    protected def createNode(Object name) { createNode(name, [:], '') }
-
-    @Override
-    protected def createNode(Object name, Object value) { createNode(name, [:], value) }
-
-    @Override
-    protected def createNode(Object name, Map attributes) {
-      throw new UnsupportedOperationException()
-    }
-
-    @Override
-    protected def createNode(Object nodeName, Map attributes, name) {
-      if (!gradleStack.isEmpty()) {
-        gradleBuilder.current = gradleStack.peek()
-      }
-      def result = gradleBuilder."$nodeName"([name: name] + attributes)
-      gradleStack.push(result)
-      if (attributes.transitive || attributes.initial) {
-        registerTargetEntity(attributes, result)
-        if (attributes.initial) {
-          // We need to match the entity to the object that is stored at the gradle sync project changes tree.
-          initial << GradleEntityIdMapper.mapEntityToId(result)
-        }
-      }
-      if (!gradleLocalRoot) {
-        if (!intellijStack.isEmpty()) {
-          intellijBuilder.current = intellijStack.peek()
-        }
-        intellijStack.push(intellijBuilder."$nodeName"([name: name] + attributes))
-      }
-      result
-    }
-
-    private void registerTargetEntity(Map attributes, entity) {
-      if (attributes.order == null) {
-        throw new IllegalArgumentException("Detected 'initial' entity with undefined 'order' property: $entity")
-      }
-      expected << [attributes.order, entity]
-      if (!gradleLocalRoot) {
-        gradleLocalRoot = entity
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/sync/GradleMovedJarsPostProcessorTest.groovy b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/sync/GradleMovedJarsPostProcessorTest.groovy
index 593ef13adc18..e66c1e9e4561 100644
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/sync/GradleMovedJarsPostProcessorTest.groovy
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/sync/GradleMovedJarsPostProcessorTest.groovy
@@ -24,6 +24,7 @@ import org.jetbrains.plugins.gradle.testutil.AbstractGradleTest
 import org.jetbrains.plugins.gradle.util.GradleUtil
 import org.jetbrains.plugins.gradle.util.TestGradleJarManager
 import org.junit.Assert
+import org.junit.Before
 import org.junit.Test
 
 /**
diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/testutil/AbstractGradleTest.groovy b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/testutil/AbstractGradleTest.groovy
index 5fce6f1afdef..f27a64be417c 100644
--- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/testutil/AbstractGradleTest.groovy
+++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/testutil/AbstractGradleTest.groovy
@@ -1,12 +1,16 @@
 package org.jetbrains.plugins.gradle.testutil
 
+import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.libraries.Library
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.plugins.gradle.action.AbstractGradleSyncTreeFilterAction
+import org.jetbrains.plugins.gradle.autoimport.GradleAutoImporter
 import org.jetbrains.plugins.gradle.config.GradleColorAndFontDescriptorsProvider
+import org.jetbrains.plugins.gradle.config.GradleLocalSettings
+import org.jetbrains.plugins.gradle.config.GradleSettings
 import org.jetbrains.plugins.gradle.config.PlatformFacade
 import org.jetbrains.plugins.gradle.diff.GradleStructureChangesCalculator
 import org.jetbrains.plugins.gradle.diff.contentroot.GradleContentRootStructureChangesCalculator
@@ -16,8 +20,10 @@ import org.jetbrains.plugins.gradle.diff.library.GradleLibraryStructureChangesCa
 import org.jetbrains.plugins.gradle.diff.module.GradleModuleStructureChangesCalculator
 import org.jetbrains.plugins.gradle.diff.project.GradleProjectStructureChangesCalculator
 import org.jetbrains.plugins.gradle.manage.GradleDependencyManager
+import org.jetbrains.plugins.gradle.manage.GradleEntityManageHelper
 import org.jetbrains.plugins.gradle.manage.GradleJarManager
 import org.jetbrains.plugins.gradle.manage.GradleLibraryManager
+import org.jetbrains.plugins.gradle.manage.GradleProjectManager
 import org.jetbrains.plugins.gradle.model.GradleEntityOwner
 import org.jetbrains.plugins.gradle.model.gradle.GradleLibrary
 import org.jetbrains.plugins.gradle.model.gradle.LibraryPathType
@@ -89,9 +95,14 @@ public abstract class AbstractGradleTest {
     container.registerComponentImplementation(GradleDependencyManager)
     container.registerComponentImplementation(GradleLibraryManager)
     container.registerComponentImplementation(GradleJarManager, TestGradleJarManager)
+    container.registerComponentImplementation(GradleProjectManager)
     container.registerComponentImplementation(GradleDuplicateLibrariesPreProcessor)
     container.registerComponentImplementation(GradleMovedJarsPostProcessor, TestGradleMovedJarsPostProcessor)
     container.registerComponentImplementation(GradleOutdatedLibraryVersionPostProcessor)
+    container.registerComponentImplementation(GradleAutoImporter)
+    container.registerComponentImplementation(GradleSettings)
+    container.registerComponentImplementation(GradleLocalSettings)
+    container.registerComponentImplementation(GradleEntityManageHelper)
     configureContainer(container)
     
     intellij.projectStub.getComponent = { clazz -> container.getComponentInstance(clazz) }
@@ -102,6 +113,9 @@ public abstract class AbstractGradleTest {
     for (d in GradleColorAndFontDescriptorsProvider.DESCRIPTORS) {
       treeFilters[d.key] = AbstractGradleSyncTreeFilterAction.createFilter(d.key)
     }
+
+    def settings = ServiceManager.getService(intellij.project, GradleSettings.class)
+    settings.useAutoImport = false
   }
 
   protected void clearChangePostProcessors() {

From a11720fd889d7b7008768329ff722dd7d1d25d96 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 21 Feb 2013 11:57:58 +0100
Subject: [PATCH 022/354] API for conformant stub processing skip methods

---
 .../psi/impl/source/JavaLightStubBuilder.java | 129 ++++++++++++------
 .../src/com/intellij/psi/StubBuilder.java     |   9 +-
 .../psi/stubs/DefaultStubBuilder.java         |  32 +++--
 .../intellij/psi/stubs/LightStubBuilder.java  |  60 +++++---
 .../intellij/psi/impl/source/PsiFileImpl.java |  56 +++++---
 5 files changed, 191 insertions(+), 95 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
index 51170ed698c1..101dd2e02fc7 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,79 +15,118 @@
  */
 package com.intellij.psi.impl.source;
 
+import com.intellij.lang.ASTNode;
 import com.intellij.lang.LighterAST;
 import com.intellij.lang.LighterASTNode;
 import com.intellij.lang.impl.ASTNodeBuilder;
+import com.intellij.openapi.util.Ref;
 import com.intellij.psi.JavaTokenType;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiJavaFile;
 import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
-import com.intellij.psi.impl.source.tree.JavaElementType;
-import com.intellij.psi.impl.source.tree.LightTreeUtil;
-import com.intellij.psi.impl.source.tree.SourceUtil;
+import com.intellij.psi.impl.source.tree.*;
 import com.intellij.psi.stubs.LightStubBuilder;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.io.StringRef;
+import org.jetbrains.annotations.NotNull;
 
 public class JavaLightStubBuilder extends LightStubBuilder {
+  private static final TokenSet BLOCK_ELEMENTS = TokenSet.create(
+    JavaElementType.ANNOTATION, JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS);
+  private static final TokenSet BLOCK_TOKENS = TokenSet.orSet(
+    TokenSet.create(JavaTokenType.AT), ElementType.CLASS_KEYWORD_BIT_SET);
+
+  @NotNull
   @Override
-  protected StubElement createStubForFile(final PsiFile file, final LighterAST tree) {
-    if (!(file instanceof PsiJavaFile)) return super.createStubForFile(file, tree);
+  protected StubElement createStubForFile(@NotNull PsiFile file, @NotNull LighterAST tree) {
+    if (!(file instanceof PsiJavaFile)) {
+      return super.createStubForFile(file, tree);
+    }
 
     String refText = "";
-
-    final LighterASTNode pkg = LightTreeUtil.firstChildOfType(tree, tree.getRoot(), JavaElementType.PACKAGE_STATEMENT);
+    LighterASTNode pkg = LightTreeUtil.firstChildOfType(tree, tree.getRoot(), JavaElementType.PACKAGE_STATEMENT);
     if (pkg != null) {
-      final LighterASTNode ref = LightTreeUtil.firstChildOfType(tree, pkg, JavaElementType.JAVA_CODE_REFERENCE);
+      LighterASTNode ref = LightTreeUtil.firstChildOfType(tree, pkg, JavaElementType.JAVA_CODE_REFERENCE);
       if (ref != null) {
         refText = SourceUtil.getTextSkipWhiteSpaceAndComments(tree, ref);
       }
     }
-
     return new PsiJavaFileStubImpl((PsiJavaFile)file, StringRef.fromString(refText), false);
   }
 
   @Override
-  public boolean skipChildProcessingWhenBuildingStubs(final IElementType nodeType, final IElementType childType) {
-    return childType == JavaElementType.PARAMETER && nodeType != JavaElementType.PARAMETER_LIST ||
-           childType == JavaElementType.PARAMETER_LIST && nodeType == JavaElementType.LAMBDA_EXPRESSION;
+  public boolean skipChildProcessingWhenBuildingStubs(@NotNull ASTNode parent, @NotNull ASTNode node) {
+    IElementType parentType = parent.getElementType();
+    IElementType nodeType = node.getElementType();
+
+    if (nodeType == JavaElementType.PARAMETER && parentType != JavaElementType.PARAMETER_LIST) {
+      return true;
+    }
+    if (nodeType == JavaElementType.PARAMETER_LIST && parentType == JavaElementType.LAMBDA_EXPRESSION) {
+      return true;
+    }
+
+    if (nodeType == JavaElementType.CODE_BLOCK && node instanceof TreeElement) {
+      final Ref<Boolean> skip = Ref.create(true);
+
+      ((TreeElement)node).acceptTree(new RecursiveTreeElementWalkingVisitor() {
+        @Override
+        protected void visitNode(TreeElement element) {
+          if (BLOCK_ELEMENTS.contains(element.getElementType())) {
+            skip.set(false);
+            stopWalking();
+            return;
+          }
+          super.visitNode(element);
+        }
+      });
+
+      return skip.get();
+    }
+
+    return false;
   }
 
   @Override
-  public boolean skipChildProcessingWhenBuildingStubs(final LightStubBuilder builder,
-                                                      final LighterAST tree,
-                                                      final LighterASTNode parent,
-                                                      final LighterASTNode child) {
-    if (child.getTokenType() == JavaElementType.CODE_BLOCK) {
-      if (child instanceof ASTNodeBuilder.ASTUnparsedNodeMarker) {
-        ASTNodeBuilder.ASTUnparsedNodeMarker nodeMarker = (ASTNodeBuilder.ASTUnparsedNodeMarker)child;
-        final ASTNodeBuilder nodeBuilder = nodeMarker.getBuilder();
-        final int endLexemeIndex = nodeMarker.getEndLexemeIndex();
-        boolean seenNew = false;
+  protected boolean skipChildProcessingWhenBuildingStubs(@NotNull LighterAST tree, @NotNull LighterASTNode parent, @NotNull LighterASTNode node) {
+    IElementType parentType = parent.getTokenType();
+    IElementType nodeType = node.getTokenType();
 
-        for (int i = nodeMarker.getStartLexemeIndex(); i < endLexemeIndex; ++i) {
-          final IElementType type = nodeBuilder.getElementType(i);
-          if (type == JavaTokenType.NEW_KEYWORD) {
-            seenNew = true;
-          }
-          else if (seenNew && type == JavaTokenType.LBRACE) {
-            return false;
-          }
-          else if (seenNew && type == JavaTokenType.SEMICOLON) {
-            seenNew = false;
-          }
-          else if (type == JavaTokenType.AT || // local vars can be annotated and we have them in stubs!
-                   type == JavaTokenType.CLASS_KEYWORD || // local classes
-                   type == JavaTokenType.INTERFACE_KEYWORD ||
-                   type == JavaTokenType.ENUM_KEYWORD) {
-            return false;
-          }
-        }
-
-        return true;
-      }
+    if (nodeType == JavaElementType.PARAMETER && parentType != JavaElementType.PARAMETER_LIST) {
+      return true;
     }
+    if (nodeType == JavaElementType.PARAMETER_LIST && parentType == JavaElementType.LAMBDA_EXPRESSION) {
+      return true;
+    }
+
+    if (nodeType == JavaElementType.CODE_BLOCK && node instanceof ASTNodeBuilder.ASTUnparsedNodeMarker) {
+      ASTNodeBuilder.ASTUnparsedNodeMarker nodeMarker = (ASTNodeBuilder.ASTUnparsedNodeMarker)node;
+      ASTNodeBuilder nodeBuilder = nodeMarker.getBuilder();
+      boolean seenNew = false, skip = true;
+
+      for (int i = nodeMarker.getStartLexemeIndex(), endIndex = nodeMarker.getEndLexemeIndex(); i < endIndex; ++i) {
+        IElementType type = nodeBuilder.getElementType(i);
+        if (type == JavaTokenType.NEW_KEYWORD) {
+          seenNew = true;
+        }
+        else if (seenNew && type == JavaTokenType.LBRACE) {  // anonymous class
+          skip = false;
+          break;
+        }
+        else if (seenNew && type == JavaTokenType.SEMICOLON) {
+          seenNew = false;
+        }
+        else if (BLOCK_TOKENS.contains(type)) {  // annotated local variables, type annotations, local classes
+          skip = false;
+          break;
+        }
+      }
+
+      return skip;
+    }
+
     return false;
   }
-}
\ No newline at end of file
+}
diff --git a/platform/core-api/src/com/intellij/psi/StubBuilder.java b/platform/core-api/src/com/intellij/psi/StubBuilder.java
index bf3bc65cc904..d94fb4706e30 100644
--- a/platform/core-api/src/com/intellij/psi/StubBuilder.java
+++ b/platform/core-api/src/com/intellij/psi/StubBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -18,12 +18,17 @@ package com.intellij.psi;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
  * @author max
  */
 public interface StubBuilder {
-  StubElement buildStubTree(PsiFile file);
+  StubElement buildStubTree(@NotNull PsiFile file);
+
+  /**
+   * @deprecated use/implement {@linkplain com.intellij.psi.stubs.DefaultStubBuilder#skipChildProcessingWhenBuildingStubs(ASTNode, ASTNode)}
+   * (to remove in IDEA 13) */
   boolean skipChildProcessingWhenBuildingStubs(@Nullable ASTNode parent, IElementType childType);
 }
\ No newline at end of file
diff --git a/platform/core-api/src/com/intellij/psi/stubs/DefaultStubBuilder.java b/platform/core-api/src/com/intellij/psi/stubs/DefaultStubBuilder.java
index 248095e839eb..d20d3ae5117b 100644
--- a/platform/core-api/src/com/intellij/psi/stubs/DefaultStubBuilder.java
+++ b/platform/core-api/src/com/intellij/psi/stubs/DefaultStubBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -38,8 +38,8 @@ public class DefaultStubBuilder implements StubBuilder {
   }
 
   protected StubElement createStubForFile(@NotNull PsiFile file) {
-    //noinspection unchecked
-    return new PsiFileStubImpl(file);
+    @SuppressWarnings("unchecked") PsiFileStubImpl stub = new PsiFileStubImpl(file);
+    return stub;
   }
 
   private StubElement buildStubTreeFor(@NotNull PsiElement root, @NotNull StubElement parentStub) {
@@ -56,8 +56,8 @@ public class DefaultStubBuilder implements StubBuilder {
         final IStubElementType type = ((StubBasedPsiElement)elt).getElementType();
 
         if (type.shouldCreateStub(elt.getNode())) {
-          //noinspection unchecked
-          stub = type.createStub(elt, stub);
+          @SuppressWarnings("unchecked") StubElement s = type.createStub(elt, stub);
+          stub = s;
         }
       }
       else {
@@ -78,7 +78,10 @@ public class DefaultStubBuilder implements StubBuilder {
     return parentStub;
   }
 
-  protected boolean skipChildProcessingWhenBuildingStubs(@NotNull PsiElement element, @NotNull PsiElement child) {
+  /**
+   * Note to implementers: always keep in sync with {@linkplain #skipChildProcessingWhenBuildingStubs(ASTNode, ASTNode)}.
+   */
+  protected boolean skipChildProcessingWhenBuildingStubs(@NotNull PsiElement parent, @NotNull PsiElement element) {
     return false;
   }
 
@@ -97,19 +100,18 @@ public class DefaultStubBuilder implements StubBuilder {
         final IStubElementType type = (IStubElementType)nodeType;
 
         if (type.shouldCreateStub(node)) {
-          //noinspection unchecked
           PsiElement element = node.getPsi();
           if (!(element instanceof StubBasedPsiElement)) {
             LOG.error("Non-StubBasedPsiElement requests stub creation. Stub type: " + type + ", PSI: " + element);
           }
-          //noinspection unchecked
-          stub = type.createStub(element, stub);
+          @SuppressWarnings("unchecked") StubElement s = type.createStub(element, stub);
+          stub = s;
           LOG.assertTrue(stub != null, element);
         }
       }
 
       for (ASTNode childNode = node.getLastChildNode(); childNode != null; childNode = childNode.getTreePrev()) {
-        if (!skipChildProcessingWhenBuildingStubs(node, childNode.getElementType())) {
+        if (!skipChildProcessingWhenBuildingStubs(node, childNode)) {
           parentNodes.push(childNode);
           parentStubs.push(stub);
         }
@@ -119,8 +121,16 @@ public class DefaultStubBuilder implements StubBuilder {
     return parentStub;
   }
 
+  /**
+   * Note to implementers: always keep in sync with {@linkplain #skipChildProcessingWhenBuildingStubs(PsiElement, PsiElement)}.
+   * todo[r.sh] move to interface (IDEA 13)
+   */
+  public boolean skipChildProcessingWhenBuildingStubs(@NotNull ASTNode parent, @NotNull ASTNode node) {
+    return skipChildProcessingWhenBuildingStubs(parent, node.getElementType());
+  }
+
   @Override
   public boolean skipChildProcessingWhenBuildingStubs(@Nullable ASTNode parent, IElementType childType) {
     return false;
   }
-}
\ No newline at end of file
+}
diff --git a/platform/core-api/src/com/intellij/psi/stubs/LightStubBuilder.java b/platform/core-api/src/com/intellij/psi/stubs/LightStubBuilder.java
index c08771302c5b..c0dc51e2890b 100644
--- a/platform/core-api/src/com/intellij/psi/stubs/LightStubBuilder.java
+++ b/platform/core-api/src/com/intellij/psi/stubs/LightStubBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -37,12 +37,11 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.List;
 
-
 public class LightStubBuilder implements StubBuilder {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.stubs.LightStubBuilder");
 
   @Override
-  public StubElement buildStubTree(final PsiFile file) {
+  public StubElement buildStubTree(@NotNull PsiFile file) {
     final FileType fileType = file.getFileType();
     if (!(fileType instanceof LanguageFileType)) {
       LOG.error("File is not of LanguageFileType: " + fileType + ", " + file);
@@ -73,12 +72,13 @@ public class LightStubBuilder implements StubBuilder {
     return rootStub;
   }
 
+  @NotNull
   @SuppressWarnings("unchecked")
-  protected StubElement createStubForFile(final PsiFile file, final LighterAST tree) {
+  protected StubElement createStubForFile(@NotNull PsiFile file, @NotNull LighterAST tree) {
     return new PsiFileStubImpl(file);
   }
 
-  protected void buildStubTree(final LighterAST tree, final LighterASTNode root, final StubElement rootStub) {
+  protected void buildStubTree(@NotNull LighterAST tree, @NotNull LighterASTNode root, @NotNull StubElement rootStub) {
     final Stack<LighterASTNode> parents = new Stack<LighterASTNode>();
     final TIntStack childNumbers = new TIntStack();
     final Stack<List<LighterASTNode>> kinderGarden = new Stack<List<LighterASTNode>>();
@@ -94,7 +94,7 @@ public class LightStubBuilder implements StubBuilder {
     while (element != null) {
       final StubElement stub = createStub(tree, element, parentStub);
 
-      if (parent == null || !skipChildProcessingWhenBuildingStubs(this, tree, parent, element)) {
+      if (parent == null || !skipNode(tree, parent, element)) {
         final List<LighterASTNode> kids = tree.getChildren(element);
         if (!kids.isEmpty()) {
           if (parent != null) {
@@ -106,13 +106,13 @@ public class LightStubBuilder implements StubBuilder {
           parent = element;
           element = (children = kids).get(childNumber = 0);
           parentStub = stub;
-          if (!skipChildProcessingWhenBuildingStubs(parent.getTokenType(), element.getTokenType())) continue nextElement;
+          if (!skipNode(tree, parent, element)) continue nextElement;
         }
       }
 
       while (children != null && ++childNumber < children.size()) {
         element = children.get(childNumber);
-        if (!skipChildProcessingWhenBuildingStubs(parent.getTokenType(), element.getTokenType())) continue nextElement;
+        if (!skipNode(tree, parent, element)) continue nextElement;
       }
 
       element = null;
@@ -123,7 +123,7 @@ public class LightStubBuilder implements StubBuilder {
         parentStub = parentStubs.pop();
         while (++childNumber < children.size()) {
           element = children.get(childNumber);
-          if (!skipChildProcessingWhenBuildingStubs(parent.getTokenType(), element.getTokenType())) continue nextElement;
+          if (!skipNode(tree, parent, element)) continue nextElement;
         }
         element = null;
       }
@@ -148,18 +148,41 @@ public class LightStubBuilder implements StubBuilder {
     return parentStub;
   }
 
+  private boolean skipNode(@NotNull LighterAST tree, @NotNull LighterASTNode parent, @NotNull LighterASTNode node) {
+    if (tree instanceof TreeBackedLighterAST) {
+      return skipChildProcessingWhenBuildingStubs(((TreeBackedLighterAST)tree).unwrap(parent), ((TreeBackedLighterAST)tree).unwrap(node));
+    }
+    else {
+      return skipChildProcessingWhenBuildingStubs(tree, parent, node);
+    }
+  }
+
+  /**
+   * Note to implementers: always keep in sync with {@linkplain #skipChildProcessingWhenBuildingStubs(LighterAST, LighterASTNode, LighterASTNode)}.
+   * todo[r.sh] move to interface (IDEA 13)
+   */
+  @SuppressWarnings("deprecation")
+  public boolean skipChildProcessingWhenBuildingStubs(@NotNull ASTNode parent, @NotNull ASTNode node) {
+    return skipChildProcessingWhenBuildingStubs(parent, node.getElementType());
+  }
+
+  /**
+   * Note to implementers: always keep in sync with {@linkplain #skipChildProcessingWhenBuildingStubs(ASTNode, ASTNode)}.
+   */
+  @SuppressWarnings("deprecation")
+  protected boolean skipChildProcessingWhenBuildingStubs(@NotNull LighterAST tree, @NotNull LighterASTNode parent, @NotNull LighterASTNode node) {
+    return skipChildProcessingWhenBuildingStubs(parent.getTokenType(), node.getTokenType());
+  }
+
+  /** @deprecated override {@linkplain #skipChildProcessingWhenBuildingStubs(ASTNode, ASTNode)} (to remove in IDEA 13) */
+  @SuppressWarnings("deprecation")
   @Override
   public final boolean skipChildProcessingWhenBuildingStubs(@Nullable ASTNode parent, IElementType childType) {
     return skipChildProcessingWhenBuildingStubs(parent != null ? parent.getElementType() : null, childType);
   }
 
-  public boolean skipChildProcessingWhenBuildingStubs(final LightStubBuilder builder,
-                                                      final LighterAST tree,
-                                                      final LighterASTNode parent,
-                                                      final LighterASTNode child) {
-    return false;
-  }
-
+  /** @deprecated override {@linkplain #skipChildProcessingWhenBuildingStubs(LighterAST, LighterASTNode, LighterASTNode)} (to remove in IDEA 13) */
+  @SuppressWarnings("unused")
   public boolean skipChildProcessingWhenBuildingStubs(final IElementType parent, final IElementType childType) {
     return false;
   }
@@ -237,6 +260,11 @@ public class LightStubBuilder implements StubBuilder {
       return new NodeWrapper(node);
     }
 
+    @NotNull
+    public ASTNode unwrap(LighterASTNode node) {
+      return ((NodeWrapper)node).myNode;
+    }
+
     private static class NodeWrapper implements LighterASTNode {
       protected final ASTNode myNode;
 
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
index a71d800d7585..746e229bc258 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -278,38 +278,40 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
 
     ((TreeElement)root).acceptTree(new RecursiveTreeElementWalkingVisitor() {
       @Override
-      protected void visitNode(TreeElement tree) {
-        final IElementType type = tree.getElementType();
-        final CompositeElement treeParent = tree.getTreeParent();
-        if (treeParent != null && builder.skipChildProcessingWhenBuildingStubs(treeParent, type)) {
+      protected void visitNode(TreeElement node) {
+        CompositeElement parent = node.getTreeParent();
+        if (parent != null && skipNode(builder, parent, node)) {
           return;
         }
-        if (type instanceof IStubElementType && ((IStubElementType)type).shouldCreateStub(tree)) {
+
+        IElementType type = node.getElementType();
+        if (type instanceof IStubElementType && ((IStubElementType)type).shouldCreateStub(node)) {
           if (!stubs.hasNext()) {
             rebuildStub();
             LOG.error("Stub list in " + getName() + " has fewer elements than PSI. Last AST element: " +
-                      tree.getElementType() + " " + tree);
+                      node.getElementType() + " " + node);
             stopWalking();
             return;
           }
 
           final StubElement stub = stubs.next();
-          if (stub.getStubType() != tree.getElementType()) {
+          if (stub.getStubType() != node.getElementType()) {
             rebuildStub();
             LOG.error("Stub and PSI element type mismatch in " + getName() + ": stub " + stub + ", AST " +
-                      tree.getElementType() + "; " + tree);
+                      node.getElementType() + "; " + node);
             stopWalking();
             return;
           }
 
           PsiElement psi = stub.getPsi();
           assert psi != null : "Stub " + stub + " (" + stub.getClass() + ") has returned null PSI";
-          ((CompositeElement)tree).setPsi(psi);
+          ((CompositeElement)node).setPsi(psi);
           StubBasedPsiElementBase<?> base = (StubBasedPsiElementBase)psi;
-          base.setNode(tree);
+          base.setNode(node);
           base.setStub(null);
         }
-        super.visitNode(tree);
+
+        super.visitNode(node);
       }
     });
   }
@@ -672,7 +674,7 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
     final IElementType contentElementType = getContentElementType();
     if (!(contentElementType instanceof IStubFileElementType)) {
       final FileViewProvider viewProvider = getViewProvider();
-      throw new AssertionError("A stub in a non-stub file '" + vFile +"'; isValid()=" + vFile.isValid() + 
+      throw new AssertionError("A stub in a non-stub file '" + vFile +"'; isValid()=" + vFile.isValid() +
                                "; IndexStamp="+ StubTreeLoader.getInstance().getStubTreeTimestamp(vFile)  +
                                "; Type: " + contentElementType + "; " +
                                "Psi roots: " + viewProvider.getAllFiles() + "; " +
@@ -993,18 +995,30 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
     bindStubs(fileRoot, stubs, ((IStubFileElementType)getContentElementType()).getBuilder());
   }
 
+  @SuppressWarnings("deprecation")
+  private static boolean skipNode(@NotNull StubBuilder builder, @NotNull ASTNode parent, @NotNull ASTNode node) {
+    if (builder instanceof DefaultStubBuilder) {
+      return ((DefaultStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
+    }
+    else if (builder instanceof LightStubBuilder) {
+      return ((LightStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
+    }
+    else {
+      return builder.skipChildProcessingWhenBuildingStubs(parent, node.getElementType());
+    }
+  }
+
   private void bindStubs(final ASTNode tree, final Iterator<StubElement<?>> stubs, final StubBuilder builder) {
     ((TreeElement)tree).acceptTree(new RecursiveTreeElementWalkingVisitor() {
       @Override
-      protected void visitNode(TreeElement root) {
-        CompositeElement parent = root.getTreeParent();
-        IElementType parentType = parent == null ? null : parent.getElementType();
-        final IElementType type = root.getElementType();
-        if (parentType != null && builder.skipChildProcessingWhenBuildingStubs(parent, type)) {
+      protected void visitNode(TreeElement node) {
+        CompositeElement parent = node.getTreeParent();
+        if (parent != null && skipNode(builder, parent, node)) {
           return;
         }
 
-        if (type instanceof IStubElementType && ((IStubElementType) type).shouldCreateStub(root)) {
+        IElementType type = node.getElementType();
+        if (type instanceof IStubElementType && ((IStubElementType) type).shouldCreateStub(node)) {
           final StubElement stub = stubs.hasNext() ? stubs.next() : null;
           if (stub == null || stub.getStubType() != type) {
             rebuildStub();
@@ -1012,10 +1026,10 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
           }
 
           //noinspection unchecked
-          ((StubBase)stub).setPsi(root.getPsi());
+          ((StubBase)stub).setPsi(node.getPsi());
         }
 
-        super.visitNode(root);
+        super.visitNode(node);
       }
     });
   }

From 5164e918d2bb758bb96a96c773396c2ccb50793f Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 21 Feb 2013 12:41:26 +0100
Subject: [PATCH 023/354] Cleaner API for light token visiting

---
 .../psi/impl/source/JavaLightStubBuilder.java | 109 +++++++++---------
 .../lang/LighterLazyParseableNode.java        |  10 +-
 .../intellij/lang/impl/ASTNodeBuilder.java    |  34 ------
 .../intellij/lang/impl/PsiBuilderImpl.java    |  35 +++---
 4 files changed, 77 insertions(+), 111 deletions(-)
 delete mode 100644 platform/core-impl/src/com/intellij/lang/impl/ASTNodeBuilder.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
index 101dd2e02fc7..35ec9939c0f4 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
@@ -18,8 +18,7 @@ package com.intellij.psi.impl.source;
 import com.intellij.lang.ASTNode;
 import com.intellij.lang.LighterAST;
 import com.intellij.lang.LighterASTNode;
-import com.intellij.lang.impl.ASTNodeBuilder;
-import com.intellij.openapi.util.Ref;
+import com.intellij.lang.LighterLazyParseableNode;
 import com.intellij.psi.JavaTokenType;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiJavaFile;
@@ -33,11 +32,6 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 
 public class JavaLightStubBuilder extends LightStubBuilder {
-  private static final TokenSet BLOCK_ELEMENTS = TokenSet.create(
-    JavaElementType.ANNOTATION, JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS);
-  private static final TokenSet BLOCK_TOKENS = TokenSet.orSet(
-    TokenSet.create(JavaTokenType.AT), ElementType.CLASS_KEYWORD_BIT_SET);
-
   @NotNull
   @Override
   protected StubElement createStubForFile(@NotNull PsiFile file, @NotNull LighterAST tree) {
@@ -61,29 +55,12 @@ public class JavaLightStubBuilder extends LightStubBuilder {
     IElementType parentType = parent.getElementType();
     IElementType nodeType = node.getElementType();
 
-    if (nodeType == JavaElementType.PARAMETER && parentType != JavaElementType.PARAMETER_LIST) {
-      return true;
-    }
-    if (nodeType == JavaElementType.PARAMETER_LIST && parentType == JavaElementType.LAMBDA_EXPRESSION) {
-      return true;
-    }
+    if (checkByTypes(parentType, nodeType)) return true;
 
     if (nodeType == JavaElementType.CODE_BLOCK && node instanceof TreeElement) {
-      final Ref<Boolean> skip = Ref.create(true);
-
-      ((TreeElement)node).acceptTree(new RecursiveTreeElementWalkingVisitor() {
-        @Override
-        protected void visitNode(TreeElement element) {
-          if (BLOCK_ELEMENTS.contains(element.getElementType())) {
-            skip.set(false);
-            stopWalking();
-            return;
-          }
-          super.visitNode(element);
-        }
-      });
-
-      return skip.get();
+      CodeBlockVisitor visitor = new CodeBlockVisitor();
+      ((TreeElement)node).acceptTree(visitor);
+      return visitor.result;
     }
 
     return false;
@@ -94,6 +71,18 @@ public class JavaLightStubBuilder extends LightStubBuilder {
     IElementType parentType = parent.getTokenType();
     IElementType nodeType = node.getTokenType();
 
+    if (checkByTypes(parentType, nodeType)) return true;
+
+    if (nodeType == JavaElementType.CODE_BLOCK && node instanceof LighterLazyParseableNode) {
+      CodeBlockVisitor visitor = new CodeBlockVisitor();
+      ((LighterLazyParseableNode)node).accept(visitor);
+      return visitor.result;
+    }
+
+    return false;
+  }
+
+  private static boolean checkByTypes(IElementType parentType, IElementType nodeType) {
     if (nodeType == JavaElementType.PARAMETER && parentType != JavaElementType.PARAMETER_LIST) {
       return true;
     }
@@ -101,32 +90,44 @@ public class JavaLightStubBuilder extends LightStubBuilder {
       return true;
     }
 
-    if (nodeType == JavaElementType.CODE_BLOCK && node instanceof ASTNodeBuilder.ASTUnparsedNodeMarker) {
-      ASTNodeBuilder.ASTUnparsedNodeMarker nodeMarker = (ASTNodeBuilder.ASTUnparsedNodeMarker)node;
-      ASTNodeBuilder nodeBuilder = nodeMarker.getBuilder();
-      boolean seenNew = false, skip = true;
-
-      for (int i = nodeMarker.getStartLexemeIndex(), endIndex = nodeMarker.getEndLexemeIndex(); i < endIndex; ++i) {
-        IElementType type = nodeBuilder.getElementType(i);
-        if (type == JavaTokenType.NEW_KEYWORD) {
-          seenNew = true;
-        }
-        else if (seenNew && type == JavaTokenType.LBRACE) {  // anonymous class
-          skip = false;
-          break;
-        }
-        else if (seenNew && type == JavaTokenType.SEMICOLON) {
-          seenNew = false;
-        }
-        else if (BLOCK_TOKENS.contains(type)) {  // annotated local variables, type annotations, local classes
-          skip = false;
-          break;
-        }
-      }
-
-      return skip;
-    }
-
     return false;
   }
+
+  private static class CodeBlockVisitor extends RecursiveTreeElementWalkingVisitor implements LighterLazyParseableNode.Visitor {
+    private static final TokenSet BLOCK_ELEMENTS = TokenSet.create(
+      JavaElementType.ANNOTATION, JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS);
+    private static final TokenSet BLOCK_TOKENS = TokenSet.orSet(
+      TokenSet.create(JavaTokenType.AT), ElementType.CLASS_KEYWORD_BIT_SET);
+
+    private boolean result = true;
+    private boolean seenNew = false;
+
+    @Override
+    protected void visitNode(TreeElement element) {
+      if (BLOCK_ELEMENTS.contains(element.getElementType())) {
+        result = false;
+        stopWalking();
+        return;
+      }
+      super.visitNode(element);
+    }
+
+    @Override
+    public boolean visit(IElementType type) {
+      if (type == JavaTokenType.NEW_KEYWORD) {
+        seenNew = true;
+      }
+      else if (seenNew && type == JavaTokenType.LBRACE) {  // anonymous class
+        result = false;
+      }
+      else if (seenNew && type == JavaTokenType.SEMICOLON) {
+        seenNew = false;
+      }
+      else if (BLOCK_TOKENS.contains(type)) {  // annotated local variables, type annotations, local classes
+        result = false;
+      }
+
+      return result;
+    }
+  }
 }
diff --git a/platform/core-api/src/com/intellij/lang/LighterLazyParseableNode.java b/platform/core-api/src/com/intellij/lang/LighterLazyParseableNode.java
index b7b899f1b74a..424072bb36c4 100644
--- a/platform/core-api/src/com/intellij/lang/LighterLazyParseableNode.java
+++ b/platform/core-api/src/com/intellij/lang/LighterLazyParseableNode.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2010 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -16,7 +16,9 @@
 package com.intellij.lang;
 
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.tree.IElementType;
 import com.intellij.util.CharTable;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 public interface LighterLazyParseableNode extends LighterASTNode {
@@ -26,4 +28,10 @@ public interface LighterLazyParseableNode extends LighterASTNode {
   CharTable getCharTable();
 
   CharSequence getText();
+
+  interface Visitor {
+    boolean visit(IElementType type);
+  }
+
+  boolean accept(@NotNull Visitor visitor);
 }
diff --git a/platform/core-impl/src/com/intellij/lang/impl/ASTNodeBuilder.java b/platform/core-impl/src/com/intellij/lang/impl/ASTNodeBuilder.java
deleted file mode 100644
index 86013d138565..000000000000
--- a/platform/core-impl/src/com/intellij/lang/impl/ASTNodeBuilder.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * 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.lang.impl;
-
-import com.intellij.psi.tree.IElementType;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * @author Maxim.Mossienko
- * @since 5.11.2011
- */
-public interface ASTNodeBuilder {
-  @Nullable
-  IElementType getElementType(int lexemeIndex);
-  
-  interface ASTUnparsedNodeMarker {
-    ASTNodeBuilder getBuilder();
-    int getStartLexemeIndex();
-    int getEndLexemeIndex();
-  }
-}
diff --git a/platform/core-impl/src/com/intellij/lang/impl/PsiBuilderImpl.java b/platform/core-impl/src/com/intellij/lang/impl/PsiBuilderImpl.java
index e0d559f1cbbc..365dc472cc56 100644
--- a/platform/core-impl/src/com/intellij/lang/impl/PsiBuilderImpl.java
+++ b/platform/core-impl/src/com/intellij/lang/impl/PsiBuilderImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -61,7 +61,7 @@ import java.util.Map;
 /**
  * @author max
  */
-public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, ASTNodeBuilder {
+public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder {
   private static final Logger LOG = Logger.getInstance("#com.intellij.lang.impl.PsiBuilderImpl");
 
   // function stored in PsiBuilderImpl' user data which called during reparse when merge algorithm is not sure what to merge
@@ -268,11 +268,6 @@ public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, AS
     public abstract int hc();
   }
 
-  @Override
-  public IElementType getElementType(int lexemeIndex) {
-    return lexemeIndex < myLexemeCount && lexemeIndex >= 0 ? myLexTypes[lexemeIndex] : null;
-  }
-
   public abstract static class ProductionMarker extends Node {
     protected int myLexemeIndex;
     protected WhitespacesAndCommentsBinder myEdgeTokenBinder;
@@ -521,7 +516,7 @@ public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, AS
   private static class TokenNode extends Token implements LighterASTTokenNode {
   }
 
-  private static class LazyParseableToken extends Token implements LighterLazyParseableNode, ASTUnparsedNodeMarker {
+  private static class LazyParseableToken extends Token implements LighterLazyParseableNode {
     private MyTreeStructure myParent;
     private FlyweightCapableTreeStructure<LighterASTNode> myParsed;
     private int myStartIndex;
@@ -552,20 +547,16 @@ public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, AS
     }
 
     @Override
-    public ASTNodeBuilder getBuilder() {
-      return myBuilder;
-    }
+    public boolean accept(@NotNull Visitor visitor) {
+      for (int i = myStartIndex; i < myEndIndex; i++) {
+        IElementType type = myBuilder.myLexTypes[i];
+        if (!visitor.visit(type)) {
+          return false;
+        }
+      }
 
-    @Override
-    public int getStartLexemeIndex() {
-      return myStartIndex;
+      return true;
     }
-
-    @Override
-    public int getEndLexemeIndex() {
-      return myEndIndex;
-    }
-
   }
 
   private static class DoneMarker extends ProductionMarker {
@@ -1341,7 +1332,7 @@ public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, AS
       boolean oldIsErrorElement = oldNode instanceof PsiErrorElement;
       boolean newIsErrorElement = newNode.getTokenType() == TokenType.ERROR_ELEMENT;
       if (oldIsErrorElement != newIsErrorElement) return ThreeState.NO;
-      if (oldIsErrorElement && newIsErrorElement) {
+      if (oldIsErrorElement) {
         final PsiErrorElement e1 = (PsiErrorElement)oldNode;
         return Comparing.equal(e1.getErrorDescription(), getErrorMessage(newNode)) ? ThreeState.UNSURE : ThreeState.NO;
       }
@@ -1421,7 +1412,7 @@ public class PsiBuilderImpl extends UserDataHolderBase implements PsiBuilder, AS
         boolean isForeign2 = n2.getTokenType() instanceof ForeignLeafType;
         if (isForeign1 != isForeign2) return false;
 
-        if (isForeign1 && isForeign2) {
+        if (isForeign1) {
           return n1.getText().equals(((ForeignLeafType)n2.getTokenType()).getValue());
         }
 

From 5a419aa494ea03fc9fc8ef7a966a9b101398852e Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 21 Feb 2013 18:59:37 +0100
Subject: [PATCH 024/354] Stub processing skip in Java code blocks optimized

---
 .../psi/impl/source/JavaLightStubBuilder.java | 31 +++++++++++++------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
index 35ec9939c0f4..e82a069f8f9b 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
@@ -96,11 +96,8 @@ public class JavaLightStubBuilder extends LightStubBuilder {
   private static class CodeBlockVisitor extends RecursiveTreeElementWalkingVisitor implements LighterLazyParseableNode.Visitor {
     private static final TokenSet BLOCK_ELEMENTS = TokenSet.create(
       JavaElementType.ANNOTATION, JavaElementType.CLASS, JavaElementType.ANONYMOUS_CLASS);
-    private static final TokenSet BLOCK_TOKENS = TokenSet.orSet(
-      TokenSet.create(JavaTokenType.AT), ElementType.CLASS_KEYWORD_BIT_SET);
 
     private boolean result = true;
-    private boolean seenNew = false;
 
     @Override
     protected void visitNode(TreeElement element) {
@@ -112,22 +109,36 @@ public class JavaLightStubBuilder extends LightStubBuilder {
       super.visitNode(element);
     }
 
+    private IElementType last = null;
+    private boolean seenNew = false;
+
     @Override
     public boolean visit(IElementType type) {
-      if (type == JavaTokenType.NEW_KEYWORD) {
-        seenNew = true;
+      if (ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(type)) {
+        return true;
       }
-      else if (seenNew && type == JavaTokenType.LBRACE) {  // anonymous class
-        result = false;
+
+      // annotations
+      if (type == JavaTokenType.AT) {
+        return (result = false);
+      }
+      // anonymous classes
+      else if (type == JavaTokenType.NEW_KEYWORD) {
+        seenNew = true;
       }
       else if (seenNew && type == JavaTokenType.SEMICOLON) {
         seenNew = false;
       }
-      else if (BLOCK_TOKENS.contains(type)) {  // annotated local variables, type annotations, local classes
-        result = false;
+      else if (seenNew && type == JavaTokenType.LBRACE && last != JavaTokenType.RBRACKET) {
+        return (result = false);
+      }
+      // local classes
+      else if (type == JavaTokenType.CLASS_KEYWORD && last != JavaTokenType.DOT) {
+        return (result = false);
       }
 
-      return result;
+      last = type;
+      return true;
     }
   }
 }

From 18adb1cefcdcc6eb33b3b5a17bbc2915e082c6ef Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 19:17:43 +0100
Subject: [PATCH 025/354] lambda: forbid type params in SAM methods
 (IDEA-101553)

---
 .../src/com/intellij/psi/LambdaHighlightingUtil.java       | 7 ++++++-
 .../codeInsight/daemon/lambda/FunctionalInterfaceTest.java | 4 ++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaHighlightingUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaHighlightingUtil.java
index 50030d468571..07cc842b7e05 100644
--- a/java/java-psi-api/src/com/intellij/psi/LambdaHighlightingUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/LambdaHighlightingUtil.java
@@ -32,7 +32,12 @@ public class LambdaHighlightingUtil {
     final List<MethodSignature> signatures = LambdaUtil.findFunctionCandidates(psiClass);
     if (signatures == null) return "Target type of a lambda conversion must be an interface";
     if (signatures.isEmpty()) return "No target method found";
-    return signatures.size() == 1 ? null : "Multiple non-overriding abstract methods found";
+    if (signatures.size() == 1) {
+      final MethodSignature functionalMethod = signatures.get(0);
+      if (functionalMethod.getTypeParameters().length > 0) return "Target method is generic";
+      return null;
+    }
+    return "Multiple non-overriding abstract methods found";
   }
 
   public static String checkReturnTypeCompatible(PsiLambdaExpression lambdaExpression, PsiType functionalInterfaceReturnType) {
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FunctionalInterfaceTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FunctionalInterfaceTest.java
index dba52b706502..88412778ea29 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FunctionalInterfaceTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/FunctionalInterfaceTest.java
@@ -76,11 +76,11 @@ public class FunctionalInterfaceTest extends LightDaemonAnalyzerTestCase {
   }
   
   public void testMethodWithTypeParam() throws Exception {
-    doTestFunctionalInterface(null);
+    doTestFunctionalInterface("Target method is generic");
   }
   
   public void testTwoMethodsSameSignatureTypeParams() throws Exception {
-    doTestFunctionalInterface(null);
+    doTestFunctionalInterface("Target method is generic");
   }
 
   public void testAbstractClass() throws Exception {

From c1d5562e8639c813fcbd4ad8d935e1e33490ba14 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 20:14:41 +0100
Subject: [PATCH 026/354] javafx: make tag types depend on hierarchy position
 (IDEA-101617)

---
 .../javaFX/fxml/JavaFXHighlightingTest.java   |  5 ++++
 .../javaFX/fxml/JavaFXNSDescriptor.java       | 20 ++++++-------
 .../plugins/javaFX/fxml/JavaFxPsiUtil.java    | 11 +------
 .../JavaFxDefaultTagInspection.java           |  7 +++--
 .../JavaFxClassBackedElementDescriptor.java   | 30 +++++++++++--------
 ...avaFxDefaultPropertyElementDescriptor.java | 14 ++++++---
 .../JavaFxPropertyElementDescriptor.java      |  8 +----
 .../highlighting/custom/_CustomVBox.java      | 16 ++++++++++
 .../custom/customComponent_Fields.fxml        |  5 ++++
 9 files changed, 69 insertions(+), 47 deletions(-)
 create mode 100644 plugins/javaFX/testData/highlighting/custom/_CustomVBox.java
 create mode 100644 plugins/javaFX/testData/highlighting/custom/customComponent_Fields.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
index e12d14a0f7c0..666f905be3a2 100644
--- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
@@ -119,6 +119,11 @@ public class JavaFXHighlightingTest extends DaemonAnalyzerTestCase {
     doTestNavigation("CustomVBox", "tf", "custom/" + getTestName(true) + ".fxml", "custom/CustomVBox.java");
   }
 
+  public void testCustomComponent_Fields() throws Exception {
+    configureByFiles(null, "custom/" + getTestName(true) + ".fxml", "custom/_CustomVBox.java");
+    doDoTest(false, false);
+  }
+
   private void doTestNavigation(String resultClassName, String resultFieldName) throws Exception {
     doTestNavigation(resultClassName, resultFieldName, ArrayUtil.EMPTY_STRING_ARRAY);
   }
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFXNSDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFXNSDescriptor.java
index ccc02fd95a11..7044f922600d 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFXNSDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFXNSDescriptor.java
@@ -2,7 +2,9 @@ package org.jetbrains.plugins.javaFX.fxml;
 
 import com.intellij.codeInsight.daemon.Validator;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.xml.*;
+import com.intellij.psi.xml.XmlDocument;
+import com.intellij.psi.xml.XmlFile;
+import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.ArrayUtil;
 import com.intellij.xml.XmlElementDescriptor;
 import com.intellij.xml.XmlNSDescriptor;
@@ -25,19 +27,15 @@ public class JavaFXNSDescriptor implements XmlNSDescriptor, Validator<XmlDocumen
 
     if (tag.getName().equals(FxmlConstants.FX_ROOT)) {
       return new JavaFxDefaultPropertyElementDescriptor(name, tag);
-    } else if (JavaFxPsiUtil.isClassTag(name)) {
-      return new JavaFxClassBackedElementDescriptor(name, tag);
     }
-    else {
-      final XmlTag parentTag = tag.getParentTag();
-      if (parentTag != null) {
-        final XmlElementDescriptor descriptor = parentTag.getDescriptor();
-        if (descriptor != null) {
-          return descriptor.getElementDescriptor(tag, parentTag);
-        }
+    final XmlTag parentTag = tag.getParentTag();
+    if (parentTag != null) {
+      final XmlElementDescriptor descriptor = parentTag.getDescriptor();
+      if (descriptor != null) {
+        return descriptor.getElementDescriptor(tag, parentTag);
       }
     }
-    return null;
+    return new JavaFxClassBackedElementDescriptor(name, tag);
   }
 
   @NotNull
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
index 27688c8d9984..ed042024c606 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
@@ -98,7 +98,7 @@ public class JavaFxPsiUtil {
 
       PsiFile file = tag.getContainingFile();
       for (String anImport : imports) {
-        if (StringUtil.endsWith(anImport, "." + name)) {
+        if (StringUtil.getShortName(anImport).equals(name)) {
           psiClass = psiFacade.findClass(anImport, file.getResolveScope()); 
         } else if (StringUtil.endsWith(anImport, ".*")) {
           psiClass = psiFacade.findClass(StringUtil.trimEnd(anImport, "*") + name, file.getResolveScope());
@@ -159,15 +159,6 @@ public class JavaFxPsiUtil {
     return null;
   }
 
-  public static boolean isClassTag(String name) {
-    final String shortName = StringUtil.getShortName(name);
-    final boolean capitalized = StringUtil.isCapitalized(name);
-    if (name.equals(shortName)) {
-      return capitalized;
-    }
-    return !capitalized;
-  }
-
   public static PsiMethod findPropertySetter(String attributeName, XmlTag context) {
     final String packageName = StringUtil.getPackageName(attributeName);
     if (context != null && !StringUtil.isEmptyOrSpaces(packageName)) {
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxDefaultTagInspection.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxDefaultTagInspection.java
index 25b96b203b9f..bedeaeec546e 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxDefaultTagInspection.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/JavaFxDefaultTagInspection.java
@@ -19,8 +19,10 @@ import com.intellij.codeInspection.*;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.psi.*;
 import com.intellij.psi.xml.XmlTag;
+import com.intellij.xml.XmlElementDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.javaFX.fxml.JavaFxPsiUtil;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxPropertyElementDescriptor;
 
 /**
  * User: anna
@@ -35,11 +37,12 @@ public class JavaFxDefaultTagInspection extends XmlSuppressableInspectionTool{
       @Override
       public void visitXmlTag(XmlTag tag) {
         super.visitXmlTag(tag);
-        final String tagName = tag.getName();
-        if (!JavaFxPsiUtil.isClassTag(tagName)) {
+        final XmlElementDescriptor descriptor = tag.getDescriptor();
+        if (descriptor instanceof JavaFxPropertyElementDescriptor) {
           final XmlTag parentTag = tag.getParentTag();
           if (parentTag != null) {
             final String propertyName = JavaFxPsiUtil.getDefaultPropertyName(JavaFxPsiUtil.getTagClass(parentTag));
+            final String tagName = tag.getName();
             if (Comparing.strEqual(tagName, propertyName)) {
               holder.registerProblem(tag.getFirstChild(), 
                                      "Default property tag could be removed", 
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
index 9e4eae7a3063..e450e00cbb5b 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
@@ -136,23 +136,27 @@ public class JavaFxClassBackedElementDescriptor implements XmlElementDescriptor,
   @Override
   public XmlElementDescriptor getElementDescriptor(XmlTag childTag, XmlTag contextTag) {
     final String name = childTag.getName();
-    if (JavaFxPsiUtil.isClassTag(name)) {
-      return new JavaFxClassBackedElementDescriptor(name, childTag);
+    if (FxmlConstants.FX_DEFAULT_ELEMENTS.contains(name)) {
+      return new JavaFxDefaultPropertyElementDescriptor(name, childTag);
     }
-    else {
-      final String shortName = StringUtil.getShortName(name);
-      if (!name.equals(shortName)) { //static property
-        final PsiMethod propertySetter = JavaFxPsiUtil.findPropertySetter(name, childTag);
-        if (propertySetter != null) {
-          return new JavaFxPropertyElementDescriptor(propertySetter.getContainingClass(), shortName, true);
-        }
+    final String shortName = StringUtil.getShortName(name);
+    if (!name.equals(shortName)) { //static property
+      final PsiMethod propertySetter = JavaFxPsiUtil.findPropertySetter(name, childTag);
+      if (propertySetter != null) {
+        return new JavaFxPropertyElementDescriptor(propertySetter.getContainingClass(), shortName, true);
+      }
+
+      final Project project = childTag.getProject();
+      if (JavaPsiFacade.getInstance(project).findClass(name, GlobalSearchScope.allScope(project)) == null) {
         return null;
       }
-      if (FxmlConstants.FX_DEFAULT_ELEMENTS.contains(name)) {
-        return new JavaFxDefaultPropertyElementDescriptor(name, childTag);
-      }
-      return myPsiClass != null ? new JavaFxPropertyElementDescriptor(myPsiClass, name, false) : null;
     }
+
+    final JavaFxPropertyElementDescriptor elementDescriptor = new JavaFxPropertyElementDescriptor(myPsiClass, name, false);
+    if (myPsiClass != null && elementDescriptor.getDeclaration() != null) {
+      return elementDescriptor;
+    }
+    return new JavaFxClassBackedElementDescriptor(name, childTag);
   }
 
   @Override
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxDefaultPropertyElementDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxDefaultPropertyElementDescriptor.java
index a103c8750664..e025f13a90c3 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxDefaultPropertyElementDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxDefaultPropertyElementDescriptor.java
@@ -66,11 +66,17 @@ public class JavaFxDefaultPropertyElementDescriptor implements XmlElementDescrip
   @Nullable
   @Override
   public XmlElementDescriptor getElementDescriptor(XmlTag childTag, XmlTag contextTag) {
-    if (myName.equals(FxmlConstants.FX_DEFINE) || myName.equals(FxmlConstants.FX_ROOT)) {
-      final String name = childTag.getName();
-      if (JavaFxPsiUtil.isClassTag(name)) {
-        return new JavaFxClassBackedElementDescriptor(name, childTag);
+    final String name = childTag.getName();
+    if (myName.equals(FxmlConstants.FX_DEFINE)) {
+      return new JavaFxClassBackedElementDescriptor(name, childTag);
+    }
+
+    if (myName.equals(FxmlConstants.FX_ROOT)) {
+      final JavaFxClassBackedElementDescriptor tagDescriptor = getRootTagDescriptor(contextTag);
+      if (tagDescriptor != null) {
+        return tagDescriptor.getElementDescriptor(childTag, contextTag);
       }
+      return new JavaFxClassBackedElementDescriptor(name, childTag);
     }
     return null;
   }
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyElementDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyElementDescriptor.java
index 36a4c8563228..7cd6dff8942e 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyElementDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyElementDescriptor.java
@@ -89,13 +89,7 @@ public class JavaFxPropertyElementDescriptor implements XmlElementDescriptor {
     if (FxmlConstants.FX_DEFAULT_ELEMENTS.contains(name)) {
       return new JavaFxDefaultPropertyElementDescriptor(name, childTag);
     }
-    if (JavaFxPsiUtil.isClassTag(name)) {
-      return new JavaFxClassBackedElementDescriptor(name, childTag);
-    }
-    else if (myPsiClass != null) {
-      return new JavaFxPropertyElementDescriptor(myPsiClass, name, name.indexOf('.') > 0);
-    }
-    return null;
+    return new JavaFxClassBackedElementDescriptor(name, childTag);
   }
 
   @Override
diff --git a/plugins/javaFX/testData/highlighting/custom/_CustomVBox.java b/plugins/javaFX/testData/highlighting/custom/_CustomVBox.java
new file mode 100644
index 000000000000..357677704951
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/custom/_CustomVBox.java
@@ -0,0 +1,16 @@
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+import javafx.scene.layout.VBox;
+
+
+public class _CustomVBox extends VBox {
+    @FXML
+    private TextField tf;
+    @FXML
+    private Label lab1;
+    @FXML
+    void myMethod(){
+        lab1.setText(tf.getText());
+    }
+}
\ No newline at end of file
diff --git a/plugins/javaFX/testData/highlighting/custom/customComponent_Fields.fxml b/plugins/javaFX/testData/highlighting/custom/customComponent_Fields.fxml
new file mode 100644
index 000000000000..af7ac78b9d5e
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/custom/customComponent_Fields.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.layout.*?>
+<?import _CustomVBox?>
+<GridPane xmlns:fx="http://javafx.com/fxml" >
+  <_CustomVBox/>
+</GridPane>
\ No newline at end of file

From 25220f5f46a91f746c70f8cbe6c1c087668f007d Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Thu, 21 Feb 2013 20:19:10 +0100
Subject: [PATCH 027/354] method refs: accept generic methods in functional
 interfaces testdata

---
 .../FunctionalInterfaceMethodIsGeneric.java          | 12 ++++++++++++
 .../daemon/lambda/MethodRefHighlightingTest.java     |  5 +++++
 2 files changed, 17 insertions(+)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/FunctionalInterfaceMethodIsGeneric.java

diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/FunctionalInterfaceMethodIsGeneric.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/FunctionalInterfaceMethodIsGeneric.java
new file mode 100644
index 000000000000..ed751ea19856
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/FunctionalInterfaceMethodIsGeneric.java
@@ -0,0 +1,12 @@
+public class Test {
+
+    interface I {
+        <T> String m();
+    }
+
+    static String foo() { return null; }
+
+    public I get() {
+        return Test::foo;
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index 6f1bac4d4cd5..5900b62e57a9 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -183,6 +183,11 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testFunctionalInterfaceMethodIsGeneric() throws Exception {
+    //accepted for method ref, though forbidden for lambda
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From f36d6c99bbe9e07b9d0dd6c3a5b1a31143d59411 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Fri, 22 Feb 2013 10:50:28 +0400
Subject: [PATCH 028/354] added scripts to build standalone JPS distribution

---
 build/scripts/dist.gant    |  2 +-
 build/scripts/layouts.gant | 29 +++++++++++++++++++++--------
 2 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/build/scripts/dist.gant b/build/scripts/dist.gant
index fed966d6fc00..4abf7ef92216 100644
--- a/build/scripts/dist.gant
+++ b/build/scripts/dist.gant
@@ -106,7 +106,7 @@ def layoutAll(Map args, String home, String out, Paths _paths = null, buildJps =
   layouts.layout_core_upsource(home, paths.artifacts_core_upsource)
   notifyArtifactBuilt(paths.artifacts_core_upsource)
   if (buildJps) {
-    layouts.layout_jps(home, paths.artifacts_jps)
+    layouts.layoutCommunityJps(home, paths.artifacts_jps)
     notifyArtifactBuilt(paths.artifacts_jps)
   }
 
diff --git a/build/scripts/layouts.gant b/build/scripts/layouts.gant
index cb202f3dc436..18e2cd39d914 100644
--- a/build/scripts/layouts.gant
+++ b/build/scripts/layouts.gant
@@ -23,11 +23,6 @@ target('default': "Developers update") {
   ant.delete(dir: patchedDescriptorDir)
 }
 
-target('build-jps': 'Build JPS standalone distribution') {
-  println("Building jps standalone distribution")
-  layout_jps("$home/build/lib/jps")
-}
-
 String appInfoFileName() {
   return "idea/IdeaApplicationInfo.xml"
 }
@@ -569,7 +564,7 @@ def reorder(String home, String targetDirectory) {
   }
 }
 
-def layout_jps(String home, String target) {
+def layoutCommunityJps(String home, String target) {
   layout(target) {
     jar("util.jar") {
       module("annotations")
@@ -596,9 +591,27 @@ def layout_jps(String home, String target) {
     jar("groovy_rt.jar") {
       module("groovy_rt")
     }
-    jar("ui-designer-jps-plugin.jar") {
-      module("ui-designer-jps-plugin")
+    jar("ui-designer-jps-plugin.jar") { module("ui-designer-jps-plugin") }
+
+    jar("android-jps-plugin.jar") {
+      module("android-jps-plugin")
+      module("android-common")
+      module("android-rt")
     }
+    fileset(dir: "${home}/plugins/android/lib") {
+      include(name: "**/*.jar")
+      exclude(name: "**/ddmlib_1.jar")
+    }
+
+    jar("maven-jps-plugin.jar") { module("maven-jps-plugin") }
+    fileset(dir: "$home/plugins/maven/maven3-server-impl/lib/maven3/lib") {include(name: "plexus-utils-*.jar")}
+
+    jar("eclipse-jps-plugin.jar") {
+      module("common-eclipse-util")
+      module("eclipse-jps-plugin")
+    }
+    jar("devkit-jps-plugin.jar") { module("devkit-jps-plugin") }
+    jar("intellilang-jps-plugin.jar") { module("intellilang-jps-plugin") }
     fileset(dir: "$home/lib") {
       include(name: "jdom.jar")
       include(name: "jna.jar")

From 0ff6e96e48ef28fb6be4277bf51d38630a4b2fc6 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Fri, 22 Feb 2013 11:30:08 +0400
Subject: [PATCH 029/354] Top-Center-Bottom alignment ability (it was always
 "top")

---
 .../core-api/src/com/intellij/ui/RowIcon.java    | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/platform/core-api/src/com/intellij/ui/RowIcon.java b/platform/core-api/src/com/intellij/ui/RowIcon.java
index a9669f3f444e..b8c9372069e0 100644
--- a/platform/core-api/src/com/intellij/ui/RowIcon.java
+++ b/platform/core-api/src/com/intellij/ui/RowIcon.java
@@ -22,12 +22,20 @@ import java.awt.*;
 import java.util.Arrays;
 
 public class RowIcon implements Icon {
+  private final Alignment myAlignment;
+
+  public enum Alignment {TOP, CENTER, BOTTOM}
 
   private final Icon[] myIcons;
   private int myWidth;
   private int myHeight;
 
   public RowIcon(int iconCount/*, int orientation*/) {
+    this(iconCount, Alignment.CENTER);
+  }
+
+  public RowIcon(int iconCount, Alignment alignment) {
+    myAlignment = alignment;
     myIcons = new Icon[iconCount];
     //myOrientation = orientation;
   }
@@ -56,9 +64,15 @@ public class RowIcon implements Icon {
   @Override
   public void paintIcon(Component c, Graphics g, int x, int y) {
     int _x = x;
+    int _y = y;
     for (Icon icon : myIcons) {
       if (icon == null) continue;
-      icon.paintIcon(c, g, _x, y);
+      switch (myAlignment) {
+        case TOP: _y = y;break;
+        case CENTER: _y = (myHeight - icon.getIconHeight())/2;break;
+        case BOTTOM: _y = (myHeight - icon.getIconHeight());break;
+      }
+      icon.paintIcon(c, g, _x, _y);
       _x += icon.getIconWidth();
       //_y += icon.getIconHeight();
     }

From f3f3a740d00690df2d52a1e7b7ac96021800d0bf Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Fri, 22 Feb 2013 11:59:27 +0400
Subject: [PATCH 030/354] IDEA-101513 Task management: while building indexes
 Switch Task, then Open Task in popup gets no reaction

---
 .../src/com/intellij/tasks/actions/GotoTaskAction.java         | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/GotoTaskAction.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/GotoTaskAction.java
index 089e85ffe70b..6a067507f05c 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/GotoTaskAction.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/GotoTaskAction.java
@@ -8,6 +8,7 @@ import com.intellij.ide.util.gotoByName.SimpleChooseByNameModel;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.keymap.KeymapUtil;
 import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiManager;
@@ -31,7 +32,7 @@ import java.util.List;
 /**
  * @author Evgeny Zakrevsky
  */
-public class GotoTaskAction extends GotoActionBase {
+public class GotoTaskAction extends GotoActionBase implements DumbAware {
   public static final CreateNewTaskAction CREATE_NEW_TASK_ACTION = new CreateNewTaskAction();
   public static final String ID = "tasks.goto";
 

From 2a07369c5366f3a57bbb2448d74a0a964acb244b Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Fri, 22 Feb 2013 12:52:13 +0400
Subject: [PATCH 031/354] IDEA-101109 Impossible to import Flash Builder
 project via Import Project -> select .project file

---
 .../com/intellij/projectImport/ImportChooserStep.form    | 9 ++-------
 .../com/intellij/projectImport/ImportChooserStep.java    | 8 ++++++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.form b/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.form
index 790f007efe5b..f81a7b178612 100644
--- a/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.form
+++ b/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.form
@@ -3,7 +3,7 @@
   <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="3" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
-      <xy x="20" y="20" width="500" height="269"/>
+      <xy x="20" y="20" width="500" height="171"/>
     </constraints>
     <properties/>
     <border type="none"/>
@@ -24,7 +24,7 @@
           <text resource-bundle="messages/ProjectBundle" key="project.new.wizard.import.title"/>
         </properties>
       </component>
-      <grid id="b4cdc" layout-manager="GridLayoutManager" row-count="2" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+      <grid id="b4cdc" layout-manager="GridLayoutManager" row-count="1" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
         <margin top="0" left="0" bottom="0" right="0"/>
         <constraints>
           <grid row="2" column="0" row-span="1" col-span="1" vsize-policy="3" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
@@ -49,11 +49,6 @@
               </component>
             </children>
           </scrollpane>
-          <vspacer id="65df7">
-            <constraints>
-              <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
-            </constraints>
-          </vspacer>
         </children>
       </grid>
     </children>
diff --git a/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.java b/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.java
index e81846ed4926..07f5a8bbda8f 100644
--- a/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.java
+++ b/java/idea-ui/src/com/intellij/projectImport/ImportChooserStep.java
@@ -32,6 +32,7 @@ import com.intellij.ui.DoubleClickListener;
 import com.intellij.ui.components.JBList;
 import com.intellij.ui.components.JBRadioButton;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
 import javax.swing.event.ListSelectionEvent;
@@ -50,6 +51,7 @@ public class ImportChooserStep extends ProjectImportWizardStep {
 
   private final ProjectImportProvider[] myProviders;
   private final StepSequence mySequence;
+  @Nullable
   private ProjectImportProvider myFromSourcesProvider;
   private JBList myList;
   private JPanel myPanel;
@@ -73,7 +75,9 @@ public class ImportChooserStep extends ProjectImportWizardStep {
         model.addElement(provider);
       }
     }
-
+    if (myFromSourcesProvider == null) {
+      myCreateFromSources.setVisible(false);
+    }
     myList.setModel(model);
     myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     myList.setCellRenderer(new DefaultListCellRenderer() {
@@ -121,7 +125,7 @@ public class ImportChooserStep extends ProjectImportWizardStep {
     if (myList.getSelectedValue() != null) return;
 
     final String id = PropertiesComponent.getInstance().getValue(PREFERRED);
-    if (id == null || id.equals(myFromSourcesProvider.getId())) {
+    if (id == null || myFromSourcesProvider != null && id.equals(myFromSourcesProvider.getId())) {
       myCreateFromSources.setSelected(true);
     }
     else {

From 6e113ba3e1ebf9f895cbbe37ae7797fa8641256b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Yann=20C=C3=A9bron?= <yann.cebron@jetbrains.com>
Date: Fri, 22 Feb 2013 11:01:17 +0100
Subject: [PATCH 032/354] ContainerUtil#findAll(T[], Condition)
 performance/memory [peter]

---
 .../src/com/intellij/util/containers/ContainerUtil.java   | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/platform/util/src/com/intellij/util/containers/ContainerUtil.java b/platform/util/src/com/intellij/util/containers/ContainerUtil.java
index 89f5833e931d..4af56bf4b44b 100644
--- a/platform/util/src/com/intellij/util/containers/ContainerUtil.java
+++ b/platform/util/src/com/intellij/util/containers/ContainerUtil.java
@@ -770,7 +770,13 @@ public class ContainerUtil extends ContainerUtilRt {
 
   @NotNull
   public static <T> List<T> findAll(@NotNull T[] collection, @NotNull Condition<? super T> condition) {
-    return findAll(Arrays.asList(collection), condition);
+    final List<T> result = new SmartList<T>();
+    for (T t : collection) {
+      if (condition.value(t)) {
+        result.add(t);
+      }
+    }
+    return result;
   }
 
   @NotNull

From 4b4da64e2731248e8b2b564c24bfc6ca8fbe763e Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Fri, 22 Feb 2013 14:17:55 +0400
Subject: [PATCH 033/354] IDEA-77350 Provide proper capitalization and wording
 in the Gradle pages of New Project wizard

---
 .../resources/i18n/GradleBundle.properties     | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/plugins/gradle/resources/i18n/GradleBundle.properties b/plugins/gradle/resources/i18n/GradleBundle.properties
index 78a97c1100be..df9969acd658 100644
--- a/plugins/gradle/resources/i18n/GradleBundle.properties
+++ b/plugins/gradle/resources/i18n/GradleBundle.properties
@@ -22,21 +22,18 @@ gradle.import.structure.settings.label.name=Name:
 gradle.import.structure.settings.label.language.level=Language level:
 gradle.import.structure.settings.label.sdk=SDK:
 gradle.import.structure.settings.no.sdk.for.language.level.text=<no registered sdk matches language level>
-gradle.import.structure.settings.label.project.config.location=Project config location:
-gradle.import.structure.settings.title.project.config.location=Project config location
-gradle.import.structure.settings.label.project.compile.output.location=Project compile output location:
-gradle.import.structure.settings.title.project.compile.output.location=Project compile output
-gradle.import.structure.settings.label.module.config.location=Module config location:
-gradle.import.structure.settings.title.module.config.location=Module config location
+gradle.import.structure.settings.label.project.config.location=Project location:
+gradle.import.structure.settings.title.project.config.location=Project location
+gradle.import.structure.settings.label.project.compile.output.location=Project compiler output:
+gradle.import.structure.settings.title.project.compile.output.location=Project compiler output
+gradle.import.structure.settings.label.module.config.location=Module file location:
+gradle.import.structure.settings.title.module.config.location=Module file location
 gradle.import.structure.settings.label.export=Exported:
 gradle.import.structure.settings.label.scope=Scope:
 gradle.import.structure.settings.label.root.source=Source roots:
 gradle.import.structure.settings.label.root.test=Test roots:
 gradle.import.structure.settings.label.root.excluded=Excluded roots:
 gradle.import.structure.settings.label.jar.path=Path:
-gradle.import.structure.settings.label.library.path.binary=Binary paths
-gradle.import.structure.settings.label.library.path.source=Source paths
-gradle.import.structure.settings.label.library.path.doc=Doc paths
 gradle.import.structure.settings.label.filters=Show only:
 
 gradle.import.title.error.resolve.generic=Resolve error
@@ -69,11 +66,8 @@ gradle.sync.change.entity.type.library.dependency=library dependency
 gradle.sync.change.entity.type.jar=jar
 gradle.sync.change.dependency.scope=scope change for {0}
 gradle.sync.change.dependency.exported='exported' value change for {0}
-gradle.sync.change.library.path=library ''{0}'' binary path
 gradle.sync.change.project.name.text=project name
 gradle.sync.change.project.language.level.text=project language level change
-gradle.sync.change.dependency.common.title=Common properties
-gradle.sync.change.library.path.title=Files
 gradle.sync.change.dependency.scope.text=Scope:
 gradle.sync.change.dependency.exported.text=Exported:
 

From a86de08a82537f71475dac6434021db95dbca74a Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Fri, 22 Feb 2013 14:32:17 +0400
Subject: [PATCH 034/354] IDEA-96177 Gradle: Throwable at
 GradleShowConflictDetailsAction$1.onClosed() on closing a project when
 conflicts popup is shown

---
 .../gradle/action/GradleShowConflictDetailsAction.java      | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/action/GradleShowConflictDetailsAction.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/action/GradleShowConflictDetailsAction.java
index 0a61d888ed65..7a341fa94f77 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/action/GradleShowConflictDetailsAction.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/action/GradleShowConflictDetailsAction.java
@@ -52,7 +52,7 @@ public class GradleShowConflictDetailsAction extends AbstractGradleSyncTreeNodeA
   }
 
   @Override
-  protected void doActionPerformed(@NotNull Collection<GradleProjectStructureNode<?>> nodes, @NotNull Project project, @NotNull Tree tree) {
+  protected void doActionPerformed(@NotNull Collection<GradleProjectStructureNode<?>> nodes, @NotNull final Project project, @NotNull Tree tree) {
     assert nodes.size() == 1;
     final GradleProjectStructureNode<?> node = nodes.iterator().next();
     final GradleProjectStructureContext context = ServiceManager.getService(project, GradleProjectStructureContext.class);
@@ -80,7 +80,9 @@ public class GradleShowConflictDetailsAction extends AbstractGradleSyncTreeNodeA
     balloon.addListener(new JBPopupAdapter() {
       @Override
       public void onClosed(LightweightWindowEvent event) {
-        publisher.afterConflictUiShown();
+        if (!project.isDisposed()) {
+          publisher.afterConflictUiShown();
+        }
       }
     });
     balloon.show(new RelativePoint(tree, hintPosition), Balloon.Position.below);

From 84f8a21b6a40aff2507c85e470a932d5e575dd24 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Fri, 22 Feb 2013 11:01:14 +0400
Subject: [PATCH 035/354] standalone JPS: added parameter to specify directory
 to store caches

---
 .../src/org/jetbrains/jps/build/Standalone.java       | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/jps/standalone-builder/src/org/jetbrains/jps/build/Standalone.java b/jps/standalone-builder/src/org/jetbrains/jps/build/Standalone.java
index 1f6e04089a6d..ed66c43e7409 100644
--- a/jps/standalone-builder/src/org/jetbrains/jps/build/Standalone.java
+++ b/jps/standalone-builder/src/org/jetbrains/jps/build/Standalone.java
@@ -49,6 +49,9 @@ public class Standalone {
   @Argument(value = "script", prefix = "--", description = "Path to Groovy script which will be used to initialize global options")
   public String initializationScriptPath;
 
+  @Argument(value = "cache-dir", prefix = "--", description = "Path to directory to store build caches")
+  public String cacheDirPath;
+
   @Argument(value = "modules", prefix = "--", delimiter = ",", description = "Comma-separated list of modules to compile")
   public String[] modules = ArrayUtil.EMPTY_STRING_ARRAY;
 
@@ -117,7 +120,13 @@ public class Standalone {
     BuildType buildType = incremental ? BuildType.MAKE : BuildType.PROJECT_REBUILD;
     Set<String> modulesSet = new HashSet<String>(Arrays.asList(modules));
     List<String> artifactsList = Arrays.asList(artifacts);
-    File dataStorageRoot = Utils.getDataStorageRoot(projectPath);
+    File dataStorageRoot;
+    if (cacheDirPath != null) {
+      dataStorageRoot = new File(cacheDirPath);
+    }
+    else {
+      dataStorageRoot = Utils.getDataStorageRoot(projectPath);
+    }
     if (dataStorageRoot == null) {
       System.err.println("Error: Cannot determine build data storage root for project " + projectPath);
       return;

From fb1996db286e0fdc1585a8f7980662853600bb82 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Fri, 22 Feb 2013 11:13:09 +0400
Subject: [PATCH 036/354] logging added

---
 .../org/jetbrains/jps/model/serialization/JpsGlobalLoader.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsGlobalLoader.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsGlobalLoader.java
index ef510e534a1e..aa6950dcf063 100644
--- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsGlobalLoader.java
+++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsGlobalLoader.java
@@ -15,6 +15,7 @@
  */
 package org.jetbrains.jps.model.serialization;
 
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
@@ -35,6 +36,7 @@ import java.util.Map;
  * @author nik
  */
 public class JpsGlobalLoader extends JpsLoaderBase {
+  private static final Logger LOG = Logger.getInstance(JpsGlobalLoader.class);
   public static final String SDK_TABLE_COMPONENT_NAME = "ProjectJdkTable";
   private static final JpsElementChildRole<JpsSimpleElement<Map<String, String>>> PATH_VARIABLES_ROLE = JpsElementChildRoleBase.create("path variables");
   private static final JpsGlobalExtensionSerializer[] SERIALIZERS = {
@@ -61,6 +63,7 @@ public class JpsGlobalLoader extends JpsLoaderBase {
   }
 
   private void load(File optionsDir) {
+    LOG.debug("Loading config from " + optionsDir.getAbsolutePath());
     for (JpsGlobalExtensionSerializer serializer : SERIALIZERS) {
       loadGlobalComponents(optionsDir, serializer);
     }

From 3c0b7f9c3d932b302e2d39f80840c602fdf95e9c Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Fri, 22 Feb 2013 14:42:30 +0400
Subject: [PATCH 037/354] hide splash when welcome screen is shown: peer
 created by pack()

---
 .../platform-impl/src/com/intellij/idea/IdeaApplication.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java b/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
index 5dd2c2f5a3b9..c417d4fa7cbd 100644
--- a/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
+++ b/platform/platform-impl/src/com/intellij/idea/IdeaApplication.java
@@ -80,7 +80,7 @@ public class IdeaApplication {
     }
     else {
       patchSystem();
-      new JFrame(); // this peer will prevent shutting down our application
+      new JFrame().pack(); // this peer will prevent shutting down our application
       Splash splash = null;
       if (myArgs.length == 0) {
         myStarter = getStarter();

From daf243a6f081abed5d5b0f19612b8a60e02646c5 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Thu, 21 Feb 2013 17:57:20 +0400
Subject: [PATCH 038/354] cleanup

---
 .../openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java         | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
index 1eb154c5eabc..c3755c8f90f3 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
@@ -53,6 +53,7 @@ import java.util.*;
  * @author max
  */
 public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
+  private static final boolean CHECK = ApplicationManager.getApplication().isUnitTestMode();
   static final VirtualDirectoryImpl NULL_VIRTUAL_FILE = new VirtualDirectoryImpl("*?;%NULL", null, LocalFileSystem.getInstance(), -42, 0) {
     public String toString() {
       return "NULL";
@@ -61,7 +62,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
 
   private final NewVirtualFileSystem myFS;
 
-  // stores child files. The array is logically divided into the two halves:
+  // stores child files. The array is logically divided into the two parts:
   // left subarray for storing real files, right subarray for storing fake files with "suspicious" names
   // files in each subarray are sorted according to the compareNameTo() comparator
   private VirtualFileSystemEntry[] myChildren = EMPTY_ARRAY; // guarded by this, either real file or fake file (meaning it's not a real child but suspicious name)
@@ -502,6 +503,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
   }
 
   private static void assertConsistency(@NotNull VirtualFileSystemEntry[] array, boolean ignoreCase) {
+    if (!CHECK) return;
     for (int i = 0; i < array.length; i++) {
       VirtualFileSystemEntry file = array[i];
       if (isSuspiciousName(file) && i != array.length - 1 ) {

From e81c65a8da59fc6d6e36b6b3bb6d216982ffec22 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Fri, 22 Feb 2013 12:56:09 +0400
Subject: [PATCH 039/354] get rid of duplicate protocol

---
 .../intellij/util/lang/UrlClassLoader.java    | 32 +++++++++++++++++--
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/platform/util/src/com/intellij/util/lang/UrlClassLoader.java b/platform/util/src/com/intellij/util/lang/UrlClassLoader.java
index 85f55fa90102..50ed89449096 100644
--- a/platform/util/src/com/intellij/util/lang/UrlClassLoader.java
+++ b/platform/util/src/com/intellij/util/lang/UrlClassLoader.java
@@ -17,7 +17,8 @@
 package com.intellij.util.lang;
 
 import com.intellij.openapi.diagnostic.Logger;
-import gnu.trove.THashSet;
+import com.intellij.util.Function;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -25,6 +26,7 @@ import sun.misc.Resource;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.*;
@@ -55,8 +57,28 @@ public class UrlClassLoader extends ClassLoader {
   public UrlClassLoader(List<URL> urls, @Nullable ClassLoader parent, boolean canLockJars, boolean canUseCache, boolean acceptUnescapedUrls) {
     super(parent);
 
-    myClassPath = new ClassPath(urls.toArray(new URL[urls.size()]), canLockJars, canUseCache, acceptUnescapedUrls);
-    myURLs = new ArrayList<URL>(urls);
+    List<URL> list = ContainerUtil.map(urls, new Function<URL, URL>() {
+      @Override
+      public URL fun(URL url) {
+        return internFileProtocol(url);
+      }
+    });
+    myClassPath = new ClassPath(list.toArray(new URL[list.size()]), canLockJars, canUseCache, acceptUnescapedUrls);
+    myURLs = list;
+  }
+
+  @NotNull
+  private static URL internFileProtocol(@NotNull URL url) {
+    try {
+      if ("file".equals(url.getProtocol())) {
+        return new URL("file", url.getHost(), url.getPort(), url.getFile());
+      }
+      return url;
+    }
+    catch (MalformedURLException e) {
+      LOG.error(e);
+      return null;
+    }
   }
 
   public void addURL(URL url) {
@@ -68,6 +90,7 @@ public class UrlClassLoader extends ClassLoader {
     return Collections.unmodifiableList(myURLs);
   }
 
+  @Override
   protected Class findClass(final String name) throws ClassNotFoundException {
     Resource res = myClassPath.getResource(name.replace('.', '/').concat(CLASS_EXTENSION), false);
     if (res == null) {
@@ -83,6 +106,7 @@ public class UrlClassLoader extends ClassLoader {
   }
 
 
+  @Override
   protected Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException {
     return super.loadClass(name, resolve);
   }
@@ -126,6 +150,7 @@ public class UrlClassLoader extends ClassLoader {
     return defineClass(name, b, 0, b.length);
   }
 
+  @Override
   @Nullable  // Accessed from PluginClassLoader via reflection // TODO do we need it?
   public URL findResource(final String name) {
     final long started = myDebugTime ? System.nanoTime():0;
@@ -168,6 +193,7 @@ public class UrlClassLoader extends ClassLoader {
   }
 
   // Accessed from PluginClassLoader via reflection // TODO do we need it?
+  @Override
   protected Enumeration<URL> findResources(String name) throws IOException {
     return myClassPath.getResources(name, true);
   }

From 763a4cf884a358b38c4b8bb748ba67eb76c884f4 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Fri, 22 Feb 2013 12:58:44 +0400
Subject: [PATCH 040/354] inlined getId

---
 .../roots/impl/DirectoryIndexImpl.java        | 142 +++++++++---------
 .../openapi/roots/impl/DirectoryInfo.java     |   8 +-
 2 files changed, 74 insertions(+), 76 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java b/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
index 812488a7f47a..edb2bb87bf70 100644
--- a/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
+++ b/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
@@ -152,17 +152,17 @@ public class DirectoryIndexImpl extends DirectoryIndex {
 
       VirtualFile parent = file.getParent();
       if (!(parent instanceof NewVirtualFile)) return;
-      DirectoryInfo existing = myState.getInfo(getId(file));
+      DirectoryInfo existing = myState.getInfo(((NewVirtualFile)file).getId());
       assert existing == null : file+" -> "+existing;
-      myState = updateStateWithNewFile((NewVirtualFile)file, parent);
+      myState = updateStateWithNewFile((NewVirtualFile)file, (NewVirtualFile)parent);
     }
 
 
     @NotNull
-    private IndexState updateStateWithNewFile(@NotNull NewVirtualFile file, @NotNull VirtualFile parent) {
+    private IndexState updateStateWithNewFile(@NotNull NewVirtualFile file, @NotNull NewVirtualFile parent) {
       final IndexState originalState = myState;
       IndexState state = originalState;
-      int parentId = getId(parent);
+      int parentId = parent.getId();
       DirectoryInfo parentInfo = originalState.getInfo(parentId);
       if (parentInfo != null) {
         assertAncestor(parentInfo, parent, parentId);
@@ -184,7 +184,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
               VirtualFile f = file.findFileByRelativePath(rel);
               if (f instanceof NewVirtualFile) {
                 if (state == originalState) state = state.copy(null);
-                state.fillMapWithModuleContent(f, eachModule, f, null);
+                state.fillMapWithModuleContent((NewVirtualFile)f, eachModule, (NewVirtualFile)f, null);
               }
             }
           }
@@ -201,25 +201,25 @@ public class DirectoryIndexImpl extends DirectoryIndex {
 
       if (state == originalState) state = state.copy(null);
       VirtualFile parentContentRoot = parentInfo.getContentRoot();
-      state.fillMapWithModuleContent(file, module, parentContentRoot, null);
+      state.fillMapWithModuleContent(file, module, (NewVirtualFile)parentContentRoot, null);
 
       String parentPackage = state.myDirToPackageName.get(parentId);
 
       if (module != null) {
         if (parentInfo.isInModuleSource()) {
           String newDirPackageName = getPackageNameForSubdir(parentPackage, file.getName());
-          state.fillMapWithModuleSource(module, parentContentRoot, file, newDirPackageName, parentInfo.getSourceRoot(), parentInfo.isTestSource(), null);
+          state.fillMapWithModuleSource(module, (NewVirtualFile)parentContentRoot, file, newDirPackageName, (NewVirtualFile)parentInfo.getSourceRoot(), parentInfo.isTestSource(), null);
         }
       }
 
       if (parentInfo.hasLibraryClassRoot()) {
         String newDirPackageName = getPackageNameForSubdir(parentPackage, file.getName());
-        state.fillMapWithLibraryClasses(file, newDirPackageName, parentInfo.getLibraryClassRoot(), null);
+        state.fillMapWithLibraryClasses(file, newDirPackageName, (NewVirtualFile)parentInfo.getLibraryClassRoot(), null);
       }
 
       if (parentInfo.isInLibrarySource()) {
         String newDirPackageName = getPackageNameForSubdir(parentPackage, file.getName());
-        state.fillMapWithLibrarySources(file, newDirPackageName, parentInfo.getSourceRoot(), null);
+        state.fillMapWithLibrarySources(file, newDirPackageName, (NewVirtualFile)parentInfo.getSourceRoot(), null);
       }
 
       OrderEntry[] entries = parentInfo.getOrderEntries();
@@ -235,7 +235,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     public void beforeFileDeletion(VirtualFileEvent event) {
       VirtualFile file = event.getFile();
       if (!file.isDirectory()) return;
-      if (myState.getInfo(getId(file)) == null) return;
+      if (myState.getInfo(((NewVirtualFile)file).getId()) == null) return;
 
       TIntArrayList list = new TIntArrayList();
       addDirsRecursively(myState, list, file);
@@ -244,7 +244,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
 
     private void addDirsRecursively(@NotNull IndexState state, @NotNull TIntArrayList list, @NotNull VirtualFile dir) {
       if (!(dir instanceof NewVirtualFile)) return;
-      int id = getId(dir);
+      int id = ((NewVirtualFile)dir).getId();
       if (state.getInfo(id) == null) return;
 
       list.add(id);
@@ -323,7 +323,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
         public boolean execute(@NotNull final Pair<IndexState, List<VirtualFile>> stateAndDirs,
                                @NotNull final Processor<VirtualFile> consumer) {
           for (VirtualFile dir : stateAndDirs.second) {
-            DirectoryInfo info = stateAndDirs.first.myDirToInfoMap.get(getId(dir));
+            DirectoryInfo info = stateAndDirs.first.myDirToInfoMap.get(((NewVirtualFile)dir).getId());
             assert info != null;
 
             if (!info.isInLibrarySource() || info.isInModuleSource() || info.hasLibraryClassRoot()) {
@@ -446,14 +446,14 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     checkAvailability();
     dispatchPendingEvents();
 
-    if (!(dir instanceof VirtualFileWithId)) return null;
-    return myState.getInfo(getId(dir));
+    if (!(dir instanceof NewVirtualFile)) return null;
+    return myState.getInfo(((NewVirtualFile)dir).getId());
   }
 
   @Override
   public boolean isProjectExcludeRoot(@NotNull VirtualFile dir) {
     checkAvailability();
-    return dir instanceof VirtualFileWithId && myState.myProjectExcludeRoots.contains(getId(dir));
+    return dir instanceof NewVirtualFile && myState.myProjectExcludeRoots.contains(((NewVirtualFile)dir).getId());
   }
 
   private VirtualFile findFileById(int dir) {
@@ -463,8 +463,8 @@ public class DirectoryIndexImpl extends DirectoryIndex {
   @Override
   public String getPackageName(@NotNull VirtualFile dir) {
     checkAvailability();
-    if (!(dir instanceof VirtualFileWithId)) return null;
-    return myState.myDirToPackageName.get(getId(dir));
+    if (!(dir instanceof NewVirtualFile)) return null;
+    return myState.myDirToPackageName.get(((NewVirtualFile)dir).getId());
   }
 
   private void checkAvailability() {
@@ -594,11 +594,11 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       }
     }
 
-    void fillMapWithModuleContent(@NotNull VirtualFile root,
+    void fillMapWithModuleContent(@NotNull NewVirtualFile root,
                                   final Module module,
-                                  final VirtualFile contentRoot,
+                                  final NewVirtualFile contentRoot,
                                   @Nullable final ProgressIndicator progress) {
-      final int contentRootId = contentRoot == null ? 0 : getId(contentRoot);
+      final int contentRootId = contentRoot == null ? 0 : contentRoot.getId();
       if (contentRoot != null) {
         assert VfsUtilCore.isAncestor(contentRoot, root, false) : "Root: "+root+"; contentRoot: "+contentRoot;
       }
@@ -611,11 +611,11 @@ public class DirectoryIndexImpl extends DirectoryIndex {
           if (isExcluded(contentRootId, file)) return null;
           if (isIgnored(file)) return null;
 
-          DirectoryInfo info = getOrCreateDirInfo(getId(file));
+          DirectoryInfo info = getOrCreateDirInfo(((NewVirtualFile)file).getId());
 
           if (info.getModule() != null) { // module contents overlap
             VirtualFile dir = file.getParent();
-            DirectoryInfo parentInfo = dir == null ? null : getInfo(getId(dir));
+            DirectoryInfo parentInfo = dir == null ? null : getInfo(((NewVirtualFile)dir).getId());
             if (parentInfo == null || !info.getModule().equals(parentInfo.getModule())) return null;
           }
 
@@ -624,7 +624,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
 
         @Override
         protected void afterChildrenVisited(@NotNull VirtualFile file, @NotNull DirectoryInfo info) {
-          with(getId(file), info, module, contentRoot, null, null, 0, null);
+          with(((NewVirtualFile)file).getId(), info, module, contentRoot, null, null, 0, null);
         }
       });
     }
@@ -641,10 +641,10 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       if (contentRoot != null) {
         assertAncestor(info, contentRoot, id);
       }
-      if (sourceRoot instanceof VirtualFileWithId) {
+      if (sourceRoot instanceof NewVirtualFile) {
         VirtualFile root = contentRoot == null ? info.getContentRoot() : contentRoot;
         if (root != null) {
-          assertAncestor(info, root, getId(sourceRoot));
+          assertAncestor(info, root, ((NewVirtualFile)sourceRoot).getId());
         }
       }
       DirectoryInfo newInfo = info.with(module, contentRoot, sourceRoot, libraryClassRoot, (byte)sourceFlag, orderEntries);
@@ -694,8 +694,8 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       }
 
       for (final VirtualFile contentRoot : contentRoots) {
-        if (contentRoot instanceof VirtualFileWithId) {
-          fillMapWithModuleContent(contentRoot, module, contentRoot, progress);
+        if (contentRoot instanceof NewVirtualFile) {
+          fillMapWithModuleContent((NewVirtualFile)contentRoot, module, (NewVirtualFile)contentRoot, progress);
         }
       }
     }
@@ -718,18 +718,18 @@ public class DirectoryIndexImpl extends DirectoryIndex {
         }
         for (SourceFolder sourceFolder : sourceFolders) {
           VirtualFile dir = sourceFolder.getFile();
-          if (dir instanceof VirtualFileWithId && contentRoot instanceof VirtualFileWithId) {
-            fillMapWithModuleSource(module, contentRoot, dir, sourceFolder.getPackagePrefix(), dir, sourceFolder.isTestSource(), progress);
+          if (dir instanceof NewVirtualFile && contentRoot instanceof NewVirtualFile) {
+            fillMapWithModuleSource(module, (NewVirtualFile)contentRoot, (NewVirtualFile)dir, sourceFolder.getPackagePrefix(), (NewVirtualFile)dir, sourceFolder.isTestSource(), progress);
           }
         }
       }
     }
 
     protected void fillMapWithModuleSource(@NotNull final Module module,
-                                           @NotNull final VirtualFile contentRoot,
-                                           @NotNull final VirtualFile dir,
+                                           @NotNull final NewVirtualFile contentRoot,
+                                           @NotNull final NewVirtualFile dir,
                                            @NotNull final String packageName,
-                                           @NotNull final VirtualFile sourceRoot,
+                                           @NotNull final NewVirtualFile sourceRoot,
                                            final boolean isTestSource,
                                            @Nullable final ProgressIndicator progress) {
       assert VfsUtilCore.isAncestor(sourceRoot, dir, false) : "SourceRoot: "+sourceRoot+" ("+sourceRoot.getFileSystem()+"); dir: "+dir+" ("+dir.getFileSystem()+")";
@@ -741,7 +741,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
           if (progress != null) {
             progress.checkCanceled();
           }
-          int id = getId(file);
+          int id = ((NewVirtualFile)file).getId();
           DirectoryInfo info = getInfo(id);
           if (info == null) return null;
           if (!module.equals(info.getModule())) return null;
@@ -781,17 +781,17 @@ public class DirectoryIndexImpl extends DirectoryIndex {
         if (orderEntry instanceof LibraryOrSdkOrderEntry) {
           VirtualFile[] sourceRoots = ((LibraryOrSdkOrderEntry)orderEntry).getRootFiles(OrderRootType.SOURCES);
           for (final VirtualFile sourceRoot : sourceRoots) {
-            if (sourceRoot instanceof VirtualFileWithId) {
-              fillMapWithLibrarySources(sourceRoot, "", sourceRoot, progress);
+            if (sourceRoot instanceof NewVirtualFile) {
+              fillMapWithLibrarySources((NewVirtualFile)sourceRoot, "", (NewVirtualFile)sourceRoot, progress);
             }
           }
         }
       }
     }
 
-    protected void fillMapWithLibrarySources(@NotNull final VirtualFile dir,
+    private void fillMapWithLibrarySources(@NotNull final NewVirtualFile dir,
                                              @Nullable final String packageName,
-                                             @NotNull final VirtualFile sourceRoot,
+                                             @NotNull final NewVirtualFile sourceRoot,
                                              @Nullable final ProgressIndicator progress) {
       VfsUtilCore.visitChildrenRecursively(dir, new VirtualFileVisitor<String>() {
         { setValueForChildren(packageName); }
@@ -799,8 +799,8 @@ public class DirectoryIndexImpl extends DirectoryIndex {
         @Override
         public boolean visitFile(@NotNull VirtualFile file) {
           if (progress != null) progress.checkCanceled();
-          int dirId = getId(file);
-          if (!file.isDirectory() && dirId != getId(dir)|| isIgnored(file)) return false;
+          int dirId = ((NewVirtualFile)file).getId();
+          if (!file.isDirectory() && dirId != dir.getId() || isIgnored(file)) return false;
           DirectoryInfo info = getOrCreateDirInfo(dirId);
 
           if (info.isInLibrarySource()) { // library sources overlap
@@ -829,17 +829,17 @@ public class DirectoryIndexImpl extends DirectoryIndex {
         if (orderEntry instanceof LibraryOrSdkOrderEntry) {
           VirtualFile[] classRoots = ((LibraryOrSdkOrderEntry)orderEntry).getRootFiles(OrderRootType.CLASSES);
           for (final VirtualFile classRoot : classRoots) {
-            if (classRoot instanceof VirtualFileWithId) {
-              fillMapWithLibraryClasses(classRoot, "", classRoot, progress);
+            if (classRoot instanceof NewVirtualFile) {
+              fillMapWithLibraryClasses((NewVirtualFile)classRoot, "", (NewVirtualFile)classRoot, progress);
             }
           }
         }
       }
     }
 
-    protected void fillMapWithLibraryClasses(@NotNull final VirtualFile dir,
+    private void fillMapWithLibraryClasses(@NotNull final NewVirtualFile dir,
                                              @NotNull final String packageName,
-                                             @NotNull final VirtualFile classRoot,
+                                             @NotNull final NewVirtualFile classRoot,
                                              @Nullable final ProgressIndicator progress) {
       VfsUtilCore.visitChildrenRecursively(dir, new VirtualFileVisitor<String>() {
         { setValueForChildren(packageName); }
@@ -849,7 +849,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
           if (progress != null) progress.checkCanceled();
           if (!file.isDirectory() && !Comparing.equal(file, dir) || isIgnored(file)) return false;
 
-          int dirId = getId(file);
+          int dirId = ((NewVirtualFile)file).getId();
           DirectoryInfo info = getOrCreateDirInfo(dirId);
 
           if (info.hasLibraryClassRoot()) { // library classes overlap
@@ -897,8 +897,8 @@ public class DirectoryIndexImpl extends DirectoryIndex {
 
           VirtualFile[] sourceRoots = ((ModuleSourceOrderEntry)orderEntry).getRootModel().getSourceRoots();
           for (VirtualFile sourceRoot : sourceRoots) {
-            if (sourceRoot instanceof VirtualFileWithId) {
-              fillMapWithOrderEntries(sourceRoot, oneEntryList, entryModule, null, null, null, progress);
+            if (sourceRoot instanceof NewVirtualFile) {
+              fillMapWithOrderEntries((NewVirtualFile)sourceRoot, oneEntryList, entryModule, null, null, null, progress);
             }
           }
         }
@@ -923,24 +923,24 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       for (Map.Entry<VirtualFile, Collection<OrderEntry>> mapEntry : depEntries.entrySet()) {
         VirtualFile vRoot = mapEntry.getKey();
         Collection<OrderEntry> entries = mapEntry.getValue();
-        if (vRoot instanceof VirtualFileWithId) {
-          fillMapWithOrderEntries(vRoot, toSortedArray(entries), null, null, null, null, progress);
+        if (vRoot instanceof NewVirtualFile) {
+          fillMapWithOrderEntries((NewVirtualFile)vRoot, toSortedArray(entries), null, null, null, null, progress);
         }
       }
 
       for (Map.Entry<VirtualFile, Collection<OrderEntry>> mapEntry : libClassRootEntries.entrySet()) {
         final VirtualFile vRoot = mapEntry.getKey();
         final Collection<OrderEntry> entries = mapEntry.getValue();
-        if (vRoot instanceof VirtualFileWithId) {
-          fillMapWithOrderEntries(vRoot, toSortedArray(entries), null, vRoot, null, null, progress);
+        if (vRoot instanceof NewVirtualFile) {
+          fillMapWithOrderEntries((NewVirtualFile)vRoot, toSortedArray(entries), null, (NewVirtualFile)vRoot, null, null, progress);
         }
       }
 
       for (Map.Entry<VirtualFile, Collection<OrderEntry>> mapEntry : libSourceRootEntries.entrySet()) {
         final VirtualFile vRoot = mapEntry.getKey();
         final Collection<OrderEntry> entries = mapEntry.getValue();
-        if (vRoot instanceof VirtualFileWithId) {
-          fillMapWithOrderEntries(vRoot, toSortedArray(entries), null, null, vRoot, null, progress);
+        if (vRoot instanceof NewVirtualFile) {
+          fillMapWithOrderEntries((NewVirtualFile)vRoot, toSortedArray(entries), null, null, (NewVirtualFile)vRoot, null, progress);
         }
       }
     }
@@ -962,11 +962,11 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     }
 
     // orderEntries must be sorted BY_OWNER_MODULE
-    protected void fillMapWithOrderEntries(@NotNull VirtualFile root,
+    protected void fillMapWithOrderEntries(@NotNull NewVirtualFile root,
                                            @NotNull final OrderEntry[] orderEntries,
                                            @Nullable final Module module,
-                                           @Nullable final VirtualFile libraryClassRoot,
-                                           @Nullable final VirtualFile librarySourceRoot,
+                                           @Nullable final NewVirtualFile libraryClassRoot,
+                                           @Nullable final NewVirtualFile librarySourceRoot,
                                            @Nullable final DirectoryInfo parentInfo,
                                            @Nullable final ProgressIndicator progress) {
       VfsUtilCore.visitChildrenRecursively(root, new DirectoryVisitor() {
@@ -979,7 +979,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
           }
           if (isIgnored(dir)) return null;
 
-          int dirId = getId(dir);
+          int dirId = ((NewVirtualFile)dir).getId();
           DirectoryInfo info = getInfo(dirId); // do not create it here!
           if (info == null) return null;
 
@@ -1102,40 +1102,40 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       for (Module module : modules) {
         for (ContentEntry contentEntry : getContentEntries(module)) {
           VirtualFile contentRoot = contentEntry.getFile();
-          if (contentRoot == null) continue;
+          if (!(contentRoot instanceof NewVirtualFile)) continue;
 
           ExcludeFolder[] excludeRoots = contentEntry.getExcludeFolders();
           for (ExcludeFolder excludeRoot : excludeRoots) {
             // Output paths should be excluded (if marked as such) regardless if they're under corresponding module's content root
             VirtualFile excludeRootFile = excludeRoot.getFile();
-            if (excludeRootFile instanceof VirtualFileWithId) {
+            if (excludeRootFile instanceof NewVirtualFile) {
               if (!FileUtil.startsWith(contentRoot.getUrl(), excludeRoot.getUrl())) {
                 if (isExcludeRootForModule(module, excludeRootFile)) {
-                  putForFileAndAllAncestors(excludeRootFile, excludeRoot.getUrl());
+                  putForFileAndAllAncestors((NewVirtualFile)excludeRootFile, excludeRoot.getUrl());
                 }
-                myProjectExcludeRoots.add(getId(excludeRootFile));
+                myProjectExcludeRoots.add(((NewVirtualFile)excludeRootFile).getId());
               }
             }
 
-            putForFileAndAllAncestors(contentRoot, excludeRoot.getUrl());
+            putForFileAndAllAncestors((NewVirtualFile)contentRoot, excludeRoot.getUrl());
           }
         }
       }
 
       for (DirectoryIndexExcludePolicy policy : myExcludePolicies) {
         for (VirtualFile file : policy.getExcludeRootsForProject()) {
-          if (file instanceof VirtualFileWithId) {
-            putForFileAndAllAncestors(file, file.getUrl());
-            myProjectExcludeRoots.add(getId(file));
+          if (file instanceof NewVirtualFile) {
+            putForFileAndAllAncestors((NewVirtualFile)file, file.getUrl());
+            myProjectExcludeRoots.add(((NewVirtualFile)file).getId());
           }
         }
       }
     }
 
-    private void putForFileAndAllAncestors(VirtualFile file, String value) {
+    private void putForFileAndAllAncestors(NewVirtualFile file, String value) {
       TIntObjectHashMap<Set<String>> map = myExcludeRootsMap;
       while (file != null) {
-        int id = getId(file);
+        int id = file.getId();
         Set<String> set = map.get(id);
         if (set == null) {
           set = new THashSet<String>();
@@ -1223,16 +1223,14 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     return result;
   }
 
-  private static int getId(@NotNull VirtualFile file) {
-    return ((VirtualFileWithId)file).getId();
-  }
-
   private void assertAncestor(@NotNull DirectoryInfo info, @NotNull VirtualFile root, int myId) {
     VirtualFile myFile = findFileById(myId);
     assert myFile.getFileSystem() == root.getFileSystem() : myFile.getFileSystem() +", "+ root.getFileSystem() +"; my file: "+myFile+"; root: "+root + "; "+
                                                             myFile.getParent().getPath().equals(root.getPath());
-    assert VfsUtilCore.isAncestor(root, myFile, false) : "my file: "+myFile+" ("+getId(myFile)+")" + myFile.getClass() + " - " +System.identityHashCode(myFile) +
-                                                         "; root: "+root +" ("+getId(root)+")" + root.getClass() + " - " +System.identityHashCode(root) +
+    assert VfsUtilCore.isAncestor(root, myFile, false) : "my file: "+myFile+" ("+
+                                                         ((NewVirtualFile)myFile).getId() +")" + myFile.getClass() + " - " +System.identityHashCode(myFile) +
+                                                         "; root: "+root +" ("+
+                                                         ((NewVirtualFile)root).getId() +")" + root.getClass() + " - " +System.identityHashCode(root) +
                                                          "; equalsToParent:"+ (myFile.getParent() == null ? "" : myFile.getParent().getPath()).equals(root.getPath()) +
                                                          "; equalsToRoot:"+ myFile.equals(root) +
                                                          "; equalsToRootPath:"+ myFile.getPath().equals(root.getPath()) +
diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
index f64f3d3a77c6..fd9cfdd86d57 100644
--- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
+++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
@@ -58,7 +58,7 @@ public final class DirectoryInfo {
    */
   private final OrderEntry[] orderEntries;
 
-  public static DirectoryInfo createNew() {
+  static DirectoryInfo createNew() {
     return new DirectoryInfo(null, null, null, null, (byte)0, null);
   }
   private DirectoryInfo(Module module,
@@ -261,7 +261,7 @@ public final class DirectoryInfo {
     }
   };
 
-  public static final Comparator<OrderEntry> BY_OWNER_MODULE = new Comparator<OrderEntry>() {
+  static final Comparator<OrderEntry> BY_OWNER_MODULE = new Comparator<OrderEntry>() {
     @Override
     public int compare(OrderEntry o1, OrderEntry o2) {
       String name1 = o1.getOwnerModule().getName();
@@ -311,7 +311,7 @@ public final class DirectoryInfo {
   }
 
   @NotNull
-  public DirectoryInfo with(Module module,
+  DirectoryInfo with(Module module,
                             VirtualFile contentRoot,
                             VirtualFile sourceRoot,
                             VirtualFile libraryClassRoot,
@@ -323,7 +323,7 @@ public final class DirectoryInfo {
   }
 
   @NotNull
-  public DirectoryInfo withInternedEntries(@NotNull OrderEntry[] orderEntries) {
+  DirectoryInfo withInternedEntries(@NotNull OrderEntry[] orderEntries) {
     return new DirectoryInfo(module, contentRoot, sourceRoot, libraryClassRoot, sourceFlag, orderEntries);
   }
 

From 422dc983c56bd0c6149b18ef5961ea8ef8469228 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 10:41:39 +0100
Subject: [PATCH 041/354] prefer longer matches to start matches (IDEA-101397)

---
 .../com/intellij/psi/util/NameUtilTest.java   | 35 ++++++++++---
 .../psi/codeStyle/MinusculeMatcher.java       | 51 +++++++------------
 2 files changed, 45 insertions(+), 41 deletions(-)

diff --git a/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java b/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
index 15e34e1e1c74..620445235846 100644
--- a/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
@@ -459,23 +459,35 @@ public class NameUtilTest extends UsefulTestCase {
     assertPreference("*psfi", "PsiJavaFileBaseImpl", "PsiFileImpl", NameUtil.MatchingCaseSensitivity.NONE);
   }
 
-  public void testPreferStartMatchToMiddleMatch() {
+  public void testPreferences() {
     assertPreference(" fb", "FooBar", "_fooBar", NameUtil.MatchingCaseSensitivity.NONE);
     assertPreference("*foo", "barFoo", "foobar");
     assertPreference("*fo", "barfoo", "barFoo");
     assertPreference("*fo", "barfoo", "foo");
     assertPreference("*fo", "asdfo", "Foo", NameUtil.MatchingCaseSensitivity.NONE);
-    assertPreference(" sto", "ArrayStoreException", "StackOverflowError", NameUtil.MatchingCaseSensitivity.NONE);
-    assertPreference(" EUC-", "x-EUC-TW", "EUC-JP");
+    assertPreference(" sto", "StackOverflowError", "ArrayStoreException", NameUtil.MatchingCaseSensitivity.NONE);
+    assertNoPreference(" EUC-", "x-EUC-TW", "EUC-JP", NameUtil.MatchingCaseSensitivity.FIRST_LETTER);
     assertPreference(" boo", "Boolean", "boolean", NameUtil.MatchingCaseSensitivity.NONE);
     assertPreference(" Boo", "boolean", "Boolean", NameUtil.MatchingCaseSensitivity.NONE);
+    assertPreference("ob", "oci_bind_array_by_name", "obj");
+    assertNoPreference("en", "ENABLED", "Enum", NameUtil.MatchingCaseSensitivity.NONE);
   }
 
   public void testPreferWordBoundaryMatch() {
     assertPreference("*ap", "add_profile", "application", NameUtil.MatchingCaseSensitivity.NONE);
-    assertPreference("*les", "configureByFiles", "getLookupElementStrings", NameUtil.MatchingCaseSensitivity.FIRST_LETTER);
+    assertPreference("*les", "configureByFiles", "getLookupElementStrings");
     assertPreference("*les", "configureByFiles", "getLookupElementStrings", NameUtil.MatchingCaseSensitivity.NONE);
     assertPreference("*ea", "LEADING", "NORTH_EAST", NameUtil.MatchingCaseSensitivity.NONE);
+
+    assertPreference("*Icon", "isControlKeyDown", "getErrorIcon", NameUtil.MatchingCaseSensitivity.NONE);
+    assertPreference("*icon", "isControlKeyDown", "getErrorIcon", NameUtil.MatchingCaseSensitivity.NONE);
+
+    assertPreference("*Icon", "getInitControl", "getErrorIcon", NameUtil.MatchingCaseSensitivity.NONE);
+    assertPreference("*icon", "getInitControl", "getErrorIcon", NameUtil.MatchingCaseSensitivity.NONE);
+  }
+
+  public void testPreferBeforeSeparators() {
+    assertPreference("*point", "getLocation(): Point", "getPoint(): Point", NameUtil.MatchingCaseSensitivity.NONE);
   }
 
   public void testPreferNoWordSkipping() {
@@ -483,12 +495,11 @@ public class NameUtilTest extends UsefulTestCase {
   }
 
   public void testWordLengthDoesNotMatter() {
-    MinusculeMatcher matcher = new MinusculeMatcher("PropComp", NameUtil.MatchingCaseSensitivity.NONE);
-    assertEquals(matcher.matchingDegree("PropertyComponent"), matcher.matchingDegree("PropertiesComponent"));
+    assertNoPreference("PropComp", "PropertyComponent", "PropertiesComponent", NameUtil.MatchingCaseSensitivity.NONE);
   }
 
-  public void testPreferEarlyMatching() {
-    assertPreference(" path", "getAbsolutePath", "findPath");
+  public void testMatchStartDoesntMatterForDegree() {
+    assertNoPreference(" path", "getAbsolutePath", "findPath", NameUtil.MatchingCaseSensitivity.FIRST_LETTER);
   }
 
   public void testMeaningfulMatchingDegree() {
@@ -511,6 +522,14 @@ public class NameUtilTest extends UsefulTestCase {
     assertTrue(iLess + ">=" + iMore + "; " + less + ">=" + more, iLess < iMore);
   }
 
+  private static void assertNoPreference(@NonNls String pattern,
+                                       @NonNls String name1,
+                                       @NonNls String name2,
+                                       NameUtil.MatchingCaseSensitivity sensitivity) {
+    MinusculeMatcher matcher = new MinusculeMatcher(pattern, sensitivity);
+    assertEquals(matcher.matchingDegree(name1), matcher.matchingDegree(name2));
+  }
+
  public void testSpeedSearchComparator() {
    final SpeedSearchComparator c = new SpeedSearchComparator(false, true);
 
diff --git a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
index 4e18662edca8..c2e19bfbddcf 100644
--- a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
+++ b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
@@ -19,7 +19,6 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.containers.FList;
 import com.intellij.util.io.IOUtil;
-import com.intellij.util.text.CharArrayUtil;
 import com.intellij.util.text.Matcher;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -32,6 +31,7 @@ import java.util.Iterator;
 * @author peter
 */
 public class MinusculeMatcher implements Matcher {
+  private static final String HARD_SEPARATORS = " ()";
   private ThreadLocal<MatchingState> myMatchingState = new ThreadLocal<MatchingState>() {
     @Override
     protected MatchingState initialValue() {
@@ -109,59 +109,44 @@ public class MinusculeMatcher implements Matcher {
   }
 
   public int matchingDegree(@NotNull String name) {
-    Iterable<TextRange> iterable = matchingFragments(name);
+    FList<TextRange> iterable = matchingFragments(name);
     if (iterable == null) return Integer.MIN_VALUE;
+    if (iterable.isEmpty()) return 0;
+
+    final TextRange first = iterable.getHead();
 
-    int fragmentCount = 0;
     int matchingCase = 0;
     int p = -1;
-    TextRange first = null;
 
     int integral = 0; // sum of matching-character-count * hump-index over all matched humps; favors longer fragments matching earlier words
-    int humpIndex = 0;
-    int nextHumpStart = name.isEmpty() ? 0: NameUtil.nextWord(name, 0);
+    int humpIndex = 1;
+    int nextHumpStart = 0;
     for (TextRange range : iterable) {
-      if (first == null) {
-        first = range;
-      }
-
       for (int i = range.getStartOffset(); i < range.getEndOffset(); i++) {
-        while (nextHumpStart < i) {
+        while (nextHumpStart <= i) {
           nextHumpStart = NameUtil.nextWord(name, nextHumpStart);
-          humpIndex++;
+          if (first != range) {
+            humpIndex++;
+          }
         }
         integral += humpIndex;
 
         char c = name.charAt(i);
-        p = CharArrayUtil.indexOf(myPattern, c, p + 1, myPattern.length);
+        p = StringUtil.indexOf(myPattern, c, p + 1, myPattern.length, false);
         if (p < 0) {
           break;
         }
-        if (isUpperCase[p] || i == range.getStartOffset()) {
-          matchingCase += c == myPattern[p] ? 1 : 0;
+        if (c == myPattern[p]) {
+          matchingCase += isUpperCase[p] ? 50 : i == range.getStartOffset() || Character.isUpperCase(c) ? 1 : 0;
         }
       }
-      fragmentCount++;
-    }
-
-    if (first == null) {
-      return 0;
-    }
-
-
-    int skipCount = CharArrayUtil.shiftForward(myPattern, 0, " *");
-    int commonStart = 0;
-    while (commonStart < name.length() &&
-           commonStart + skipCount < myPattern.length &&
-           name.charAt(commonStart) == myPattern[commonStart + skipCount]) {
-      commonStart++;
     }
 
     int startIndex = first.getStartOffset();
-    boolean prefixMatching = isStartMatch(name, startIndex);
-    boolean middleWordStart = !prefixMatching && startIndex > 0 && NameUtil.isWordStart(name, startIndex) && !NameUtil.isWordStart(name, startIndex - 1);
+    boolean afterSeparator = StringUtil.indexOfAny(name, HARD_SEPARATORS, 0, startIndex) >= 0;
+    boolean wordStart = startIndex == 0 || NameUtil.isWordStart(name, startIndex) && !NameUtil.isWordStart(name, startIndex - 1);
 
-    return -fragmentCount + matchingCase * 20 + commonStart * 30 - startIndex + (prefixMatching ? 2 : middleWordStart ? 1 : 0) * 1000 - integral;
+    return (wordStart ? 1000 : 0) - integral * 10 + matchingCase + (afterSeparator ? 0 : 1);
   }
 
   public boolean isStartMatch(@NotNull String name) {
@@ -261,7 +246,7 @@ public class MinusculeMatcher implements Matcher {
         return null;
       }
       // pattern humps are allowed to match in words separated by " ()", lowercase characters aren't
-      if (!allowSpecialChars && !myHasHumps && StringUtil.containsAnyChar(name, " ()", nameIndex, nextOccurrence)) {
+      if (!allowSpecialChars && !myHasHumps && StringUtil.containsAnyChar(name, HARD_SEPARATORS, nameIndex, nextOccurrence)) {
         return null;
       }
       // if the user has typed a dot, don't skip other dots between humps

From f4471ebbba542369111d8fe6ebecf788d9fa47bd Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 12:22:26 +0100
Subject: [PATCH 042/354] let's collect some real data on patterns searched for
 in file structure popup

---
 .../com/intellij/ide/util/FileStructurePopup.java    | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/ide/util/FileStructurePopup.java b/platform/lang-impl/src/com/intellij/ide/util/FileStructurePopup.java
index ae15cf5cfc03..4d02873f3820 100644
--- a/platform/lang-impl/src/com/intellij/ide/util/FileStructurePopup.java
+++ b/platform/lang-impl/src/com/intellij/ide/util/FileStructurePopup.java
@@ -35,6 +35,7 @@ import com.intellij.openapi.MnemonicHelper;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.command.CommandProcessor;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory;
 import com.intellij.openapi.keymap.KeymapUtil;
@@ -86,6 +87,7 @@ import java.util.List;
  * @author Konstantin Bulenkov
  */
 public class FileStructurePopup implements Disposable {
+  private static final Logger LOG = Logger.getInstance("#com.intellij.ide.util.FileStructurePopup");
   private final Editor myEditor;
   private final Project myProject;
   private final StructureViewModel myTreeModel;
@@ -596,12 +598,20 @@ public class FileStructurePopup implements Disposable {
   }
 
   public boolean navigateSelectedElement() {
+    final AbstractTreeNode selectedNode = getSelectedNode();
+    if (ApplicationManager.getApplication().isInternal()) {
+      String enteredPrefix = getSpeedSearch().getEnteredPrefix();
+      String itemText = getSpeedSearchText(selectedNode);
+      if (StringUtil.isNotEmpty(enteredPrefix) && StringUtil.isNotEmpty(itemText)) {
+        LOG.info("Chosen in file structure popup by prefix '" + enteredPrefix + "': '" + itemText + "'");
+      }
+    }
+
     final Ref<Boolean> succeeded = new Ref<Boolean>();
     final CommandProcessor commandProcessor = CommandProcessor.getInstance();
     commandProcessor.executeCommand(myProject, new Runnable() {
       @Override
       public void run() {
-        final AbstractTreeNode selectedNode = getSelectedNode();
         if (selectedNode != null) {
           if (selectedNode.canNavigateToSource()) {
             myPopup.cancel();

From e8a2a173841102feb74cb72e798ded695915480b Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 12:24:02 +0100
Subject: [PATCH 043/354] honor statistics and prefix matching degree in groovy
 completion

---
 plugins/groovy/src/META-INF/plugin.xml           |  4 ++--
 .../completion/GroovyCompletionTest.groovy       | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml
index bcbe434cdee0..703f940e64d6 100644
--- a/plugins/groovy/src/META-INF/plugin.xml
+++ b/plugins/groovy/src/META-INF/plugin.xml
@@ -355,9 +355,9 @@
     <psi.referenceContributor  language="Properties" implementation="org.jetbrains.plugins.groovy.dgm.DGMReferenceContributor"/>
 
     <weigher key="completion" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrWithWeigher"
-             id="groovyWithWeigher" order="before stats"/>
+             id="groovyWithWeigher" order="after prefix"/>
     <weigher key="completion" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrKindWeigher"
-             id="groovyKindWeigher" order="before stats, after groovyWithWeigher"/>
+             id="groovyKindWeigher" order="after groovyWithWeigher, before explicitProximity"/>
 
     <weigher key="proximity" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrReferenceListWeigher"
              id="groovyReferenceListWeigher" order="before openedInEditor"/>
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
index 20a8e57a3bcd..11d29c2081e8 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
@@ -15,7 +15,6 @@
  */
 
 package org.jetbrains.plugins.groovy.completion
-
 import com.intellij.codeInsight.CodeInsightSettings
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.codeInsight.completion.impl.CamelHumpMatcher
@@ -23,6 +22,8 @@ import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.codeInsight.lookup.LookupElementPresentation
 import com.intellij.codeInsight.lookup.PsiTypeLookupItem
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager
+import com.intellij.psi.statistics.StatisticsManager
+import com.intellij.psi.statistics.impl.StatisticsManagerImpl
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.plugins.groovy.GroovyFileType
 import org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleSettings
@@ -1670,4 +1671,17 @@ void foo() {
   <caret> = baz
 }""")
   }
+
+  public void "test honor statistics"() {
+    ((StatisticsManagerImpl)StatisticsManager.instance).enableStatistics(testRootDisposable)
+
+    myFixture.addClass("class Foo { Object getMessage() {} }; class Bar extends Foo { Object getMessages(); }")
+    configure "b = new Bar();\nb.mes<caret>"
+    def items = myFixture.completeBasic()
+    myFixture.assertPreferredCompletionItems 0, "messages", "message"
+    myFixture.lookup.currentItem = items[1]
+    myFixture.type('\n\nb.mes')
+    myFixture.completeBasic()
+    myFixture.assertPreferredCompletionItems 0, "message", "messages"
+  }
 }
\ No newline at end of file

From 8000167bd6919869f724605c616da5dec5708b3f Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Fri, 22 Feb 2013 12:23:05 +0100
Subject: [PATCH 044/354] Diff colors

---
 colorSchemes/src/colorSchemes/Darcula.xml | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 5546bed865e6..9d5d944c35ca 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -415,26 +415,26 @@
     </option>
     <option name="DIFF_CONFLICT">
       <value>
-        <option name="BACKGROUND" value="763c3d" />
-        <option name="ERROR_STRIPE_COLOR" value="763c3d" />
+        <option name="BACKGROUND" value="45302b" />
+        <option name="ERROR_STRIPE_COLOR" value="8f5247" />
       </value>
     </option>
     <option name="DIFF_DELETED">
       <value>
-        <option name="BACKGROUND" value="0" />
-        <option name="ERROR_STRIPE_COLOR" value="0" />
+        <option name="BACKGROUND" value="484a4a" />
+        <option name="ERROR_STRIPE_COLOR" value="656e76" />
       </value>
     </option>
     <option name="DIFF_INSERTED">
       <value>
-        <option name="BACKGROUND" value="365d40" />
-        <option name="ERROR_STRIPE_COLOR" value="365d40" />
+        <option name="BACKGROUND" value="294436" />
+        <option name="ERROR_STRIPE_COLOR" value="447152" />
       </value>
     </option>
     <option name="DIFF_MODIFIED">
       <value>
-        <option name="BACKGROUND" value="337184" />
-        <option name="ERROR_STRIPE_COLOR" value="326174" />
+        <option name="BACKGROUND" value="385570" />
+        <option name="ERROR_STRIPE_COLOR" value="43698d" />
       </value>
     </option>
     <option name="DOC_COMMENT_TAG_VALUE">

From 70a2761955f8fa03e538de61c3592f77045eb1f7 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 12:59:17 +0100
Subject: [PATCH 045/354] javafx: collapse property tags to attributes
 (IDEA-100231)

---
 .../JavaFXCollapseSubtagToAttributeTest.java  | 77 +++++++++++++++++++
 .../after.fxml.template                       |  2 +
 .../before.fxml.template                      |  3 +
 .../description.html                          |  6 ++
 .../src/META-INF/common-javaFX-plugin.xml     |  4 +
 ...aFxCollapseSubTagToAttributeIntention.java | 68 ++++++++++++++++
 .../collapseToAttr/additionalSubtags.fxml     | 24 ++++++
 .../intentions/collapseToAttr/simple.fxml     | 21 +++++
 .../collapseToAttr/simple_after.fxml          | 20 +++++
 .../intentions/collapseToAttr/staticAttr.fxml | 21 +++++
 .../collapseToAttr/staticAttr_after.fxml      | 20 +++++
 11 files changed, 266 insertions(+)
 create mode 100644 plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXCollapseSubtagToAttributeTest.java
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/after.fxml.template
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/before.fxml.template
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/description.html
 create mode 100644 plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxCollapseSubTagToAttributeIntention.java
 create mode 100644 plugins/javaFX/testData/intentions/collapseToAttr/additionalSubtags.fxml
 create mode 100644 plugins/javaFX/testData/intentions/collapseToAttr/simple.fxml
 create mode 100644 plugins/javaFX/testData/intentions/collapseToAttr/simple_after.fxml
 create mode 100644 plugins/javaFX/testData/intentions/collapseToAttr/staticAttr.fxml
 create mode 100644 plugins/javaFX/testData/intentions/collapseToAttr/staticAttr_after.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXCollapseSubtagToAttributeTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXCollapseSubtagToAttributeTest.java
new file mode 100644
index 000000000000..d27cd08ce0e9
--- /dev/null
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXCollapseSubtagToAttributeTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml;
+
+import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
+import com.intellij.codeInsight.daemon.impl.HighlightInfo;
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.codeInsight.intention.impl.ShowIntentionActionsHandler;
+import com.intellij.openapi.application.PluginPathManager;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.psi.PsiFile;
+import com.intellij.testFramework.PsiTestUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class JavaFXCollapseSubtagToAttributeTest extends DaemonAnalyzerTestCase {
+  @Override
+  protected void setUpModule() {
+    super.setUpModule();
+    PsiTestUtil.addLibrary(getModule(), "javafx", PluginPathManager.getPluginHomePath("javaFX") + "/testData", "jfxrt.jar");
+  }
+
+  public void testAdditionalSubtags() throws Exception {
+    doTest(false);
+  }
+
+  public void testSimple() throws Exception {
+    doTest(true);
+  }
+
+  public void testStaticAttr() throws Exception {
+    doTest(true, "GridPane.rowIndex");
+  }
+
+  private void doTest(boolean available) throws Exception {
+    doTest(available, "text");
+  }
+
+  private void doTest(boolean available, final String tagName) throws Exception {
+    configureByFiles(null, getTestName(true) + ".fxml");
+    
+    final List<HighlightInfo> infos = doHighlighting();
+    Editor editor = getEditor();
+    PsiFile file = getFile();
+    
+    IntentionAction intentionAction = findIntentionAction(infos, "Collapse tag '" + tagName + "' to attribute", editor, file);
+
+    if (available) {
+      assertNotNull("Collapse tag '" + tagName + "' to attribute", intentionAction);
+      assertTrue(ShowIntentionActionsHandler.chooseActionAndInvoke(file, editor, intentionAction,
+                                                                   "Collapse tag '" + tagName + "' to attribute"));
+      checkResultByFile(getTestName(true) + "_after.fxml");
+    } else {
+      assertNull(intentionAction);
+    }
+  }
+
+  @NotNull
+  @Override
+  protected String getTestDataPath() {
+    return PluginPathManager.getPluginHomePath("javaFX") + "/testData/intentions/collapseToAttr/";
+  }
+}
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/after.fxml.template b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/after.fxml.template
new file mode 100644
index 000000000000..aea9db5d9601
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/after.fxml.template
@@ -0,0 +1,2 @@
+<Button fx:id="btn" text="text" >
+</Button>
\ No newline at end of file
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/before.fxml.template b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/before.fxml.template
new file mode 100644
index 000000000000..15d830c7807f
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/before.fxml.template
@@ -0,0 +1,3 @@
+<Button fx:id="btn">
+      <spot><text>text</text></spot>    
+</Button>
\ No newline at end of file
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/description.html b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/description.html
new file mode 100644
index 000000000000..a87925dd86a0
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxCollapseSubTagToAttributeIntention/description.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+This intention collapses property subtag to an attribute of a parent class tag.
+</body>
+</html>
+    
\ No newline at end of file
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index bef654b8a424..9c750c058946 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -20,6 +20,10 @@
     <applicationService serviceInterface="org.jetbrains.plugins.javaFX.JavaFxSettings" serviceImplementation="org.jetbrains.plugins.javaFX.JavaFxSettings"/>
     <applicationConfigurable instance="org.jetbrains.plugins.javaFX.JavaFxSettingsConfigurable"/>
     <fileBasedIndex implementation="org.jetbrains.plugins.javaFX.JavaFxControllerClassIndex"/>
+    <intentionAction>
+      <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxCollapseSubTagToAttributeIntention</className>
+      <category>JavaFX</category>
+    </intentionAction>
   </extensions>
 
   <actions>
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxCollapseSubTagToAttributeIntention.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxCollapseSubTagToAttributeIntention.java
new file mode 100644
index 000000000000..1f772ba4765b
--- /dev/null
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxCollapseSubTagToAttributeIntention.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions;
+
+import com.intellij.codeInsight.CodeInsightUtilBase;
+import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.XmlElementFactory;
+import com.intellij.psi.xml.*;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxClassBackedElementDescriptor;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxPropertyElementDescriptor;
+
+/**
+ * User: anna
+ * Date: 2/22/13
+ */
+public class JavaFxCollapseSubTagToAttributeIntention extends PsiElementBaseIntentionAction{
+  @Override
+  public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException {
+    if (!CodeInsightUtilBase.preparePsiElementsForWrite(element)) return;
+    final XmlTag tag = (XmlTag)element.getParent();
+    final XmlAttribute attribute = XmlElementFactory.getInstance(project).createXmlAttribute(tag.getName(), tag.getValue().getText().trim());
+    final XmlTag parentTag = tag.getParentTag();
+    parentTag.add(attribute);
+    tag.delete();
+  }
+
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
+    if (element instanceof XmlToken && ((XmlToken)element).getTokenType() == XmlTokenType.XML_NAME && element.getParent() instanceof XmlTag) {
+      final XmlTag tag = (XmlTag)element.getParent();
+      if (tag.getSubTags().length == 0) {
+        final XmlTag parentTag = tag.getParentTag();
+        if (parentTag != null &&
+            tag.getDescriptor() instanceof JavaFxPropertyElementDescriptor &&
+            parentTag.getDescriptor() instanceof JavaFxClassBackedElementDescriptor) {
+  
+          setText("Collapse tag '" + tag.getName() + "' to attribute");
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  @NotNull
+  @Override
+  public String getFamilyName() {
+    return "Collapse tag to attribute";
+  }
+}
diff --git a/plugins/javaFX/testData/intentions/collapseToAttr/additionalSubtags.fxml b/plugins/javaFX/testData/intentions/collapseToAttr/additionalSubtags.fxml
new file mode 100644
index 000000000000..60316d4296ea
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/collapseToAttr/additionalSubtags.fxml
@@ -0,0 +1,24 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.chart.LineChart?>
+<GridPane fx:controller="sample.MyController" xmlns:fx="http://javafx.com/fxml" alignment="CENTER" hgap="10" vgap="10">
+    <padding>
+        <Insets top="25" right="25" bottom="10" left="25"/>
+    </padding>
+
+    <Button text="Say Hello" onAction="#sayHelloWorld"/>
+    <Label fx:id="myLabel" GridPane.rowIndex="1">
+        <te<caret>xt>
+            <fx:script></fx:script>
+            hi
+        </text>
+    </Label>
+    <ScrollPane layoutX="-15.0" layoutY="-81.0" prefHeight="205.0" prefWidth="341.0">
+        <AnchorPane id="Content" minHeight="0.0" minWidth="0.0" prefHeight="200.0" prefWidth="200.0"/>
+    </ScrollPane>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/collapseToAttr/simple.fxml b/plugins/javaFX/testData/intentions/collapseToAttr/simple.fxml
new file mode 100644
index 000000000000..28a8640de1e2
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/collapseToAttr/simple.fxml
@@ -0,0 +1,21 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.chart.LineChart?>
+<GridPane fx:controller="sample.MyController" xmlns:fx="http://javafx.com/fxml" alignment="CENTER" hgap="10" vgap="10">
+    <padding>
+        <Insets top="25" right="25" bottom="10" left="25"/>
+    </padding>
+
+    <Button text="Say Hello" onAction="#sayHelloWorld"/>
+    <Label fx:id="myLabel" GridPane.rowIndex="1">
+        <te<caret>xt>hi</text>
+    </Label>
+    <ScrollPane layoutX="-15.0" layoutY="-81.0" prefHeight="205.0" prefWidth="341.0">
+        <AnchorPane id="Content" minHeight="0.0" minWidth="0.0" prefHeight="200.0" prefWidth="200.0"/>
+    </ScrollPane>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/collapseToAttr/simple_after.fxml b/plugins/javaFX/testData/intentions/collapseToAttr/simple_after.fxml
new file mode 100644
index 000000000000..185d059ea982
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/collapseToAttr/simple_after.fxml
@@ -0,0 +1,20 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.chart.LineChart?>
+<GridPane fx:controller="sample.MyController" xmlns:fx="http://javafx.com/fxml" alignment="CENTER" hgap="10" vgap="10">
+    <padding>
+        <Insets top="25" right="25" bottom="10" left="25"/>
+    </padding>
+
+    <Button text="Say Hello" onAction="#sayHelloWorld"/>
+    <Label fx:id="myLabel" GridPane.rowIndex="1" text="hi">
+    </Label>
+    <ScrollPane layoutX="-15.0" layoutY="-81.0" prefHeight="205.0" prefWidth="341.0">
+        <AnchorPane id="Content" minHeight="0.0" minWidth="0.0" prefHeight="200.0" prefWidth="200.0"/>
+    </ScrollPane>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr.fxml b/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr.fxml
new file mode 100644
index 000000000000..4c5d33214a31
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr.fxml
@@ -0,0 +1,21 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.chart.LineChart?>
+<GridPane fx:controller="sample.MyController" xmlns:fx="http://javafx.com/fxml" alignment="CENTER" hgap="10" vgap="10">
+    <padding>
+        <Insets top="25" right="25" bottom="10" left="25"/>
+    </padding>
+
+    <Button text="Say Hello" onAction="#sayHelloWorld"/>
+    <Label fx:id="myLabel">
+      <GridPane.ro<caret>wIndex>1</GridPane.rowIndex>  
+    </Label>
+    <ScrollPane layoutX="-15.0" layoutY="-81.0" prefHeight="205.0" prefWidth="341.0">
+        <AnchorPane id="Content" minHeight="0.0" minWidth="0.0" prefHeight="200.0" prefWidth="200.0"/>
+    </ScrollPane>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr_after.fxml b/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr_after.fxml
new file mode 100644
index 000000000000..788661202817
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/collapseToAttr/staticAttr_after.fxml
@@ -0,0 +1,20 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.chart.LineChart?>
+<GridPane fx:controller="sample.MyController" xmlns:fx="http://javafx.com/fxml" alignment="CENTER" hgap="10" vgap="10">
+    <padding>
+        <Insets top="25" right="25" bottom="10" left="25"/>
+    </padding>
+
+    <Button text="Say Hello" onAction="#sayHelloWorld"/>
+    <Label fx:id="myLabel" GridPane.rowIndex="1">
+    </Label>
+    <ScrollPane layoutX="-15.0" layoutY="-81.0" prefHeight="205.0" prefWidth="341.0">
+        <AnchorPane id="Content" minHeight="0.0" minWidth="0.0" prefHeight="200.0" prefWidth="200.0"/>
+    </ScrollPane>
+</GridPane>
\ No newline at end of file

From 40d939a2adb318b4045a31c8582d94f742bb2862 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Fri, 22 Feb 2013 16:14:04 +0400
Subject: [PATCH 046/354] IDEA-100922 [rollback]

---
 .../compiler/progress/CompilerTask.java        | 18 ++----------------
 .../execution/ui/RunContentManagerImpl.java    |  2 +-
 .../com/intellij/openapi/wm/ToolWindow.java    |  7 -------
 .../wm/impl/ToolWindowHeadlessManagerImpl.java |  5 -----
 .../openapi/wm/impl/ToolWindowImpl.java        | 13 +------------
 5 files changed, 4 insertions(+), 41 deletions(-)

diff --git a/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java b/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java
index a45795603441..9c430d8a3ad9 100644
--- a/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java
+++ b/java/compiler/impl/src/com/intellij/compiler/progress/CompilerTask.java
@@ -41,7 +41,6 @@ import com.intellij.openapi.project.DumbModeAction;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
 import com.intellij.openapi.project.ProjectManagerListener;
-import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.TextRange;
@@ -210,20 +209,6 @@ public class CompilerTask extends Task.Backgroundable {
           closeUI();
         }
         stopAppIconProgress();
-
-        Runnable runnable = new Runnable() {
-          public void run() {
-            if (myProject == null || myProject.isDisposed())
-              return;
-            NotificationInfo notificationInfo = getNotificationInfo();
-            if (notificationInfo != null && !myMessagesAutoActivated && (myErrorCount > 0 || (myWarningCount > 0 && !ErrorTreeViewConfiguration.getInstance(myProject).isHideWarnings()))) {
-              MessageType messageType = myErrorCount > 0 ? MessageType.ERROR : myWarningCount > 0 ? MessageType.WARNING : MessageType.INFO;
-              ToolWindowManager.getInstance(myProject).notifyByBalloon(ToolWindowId.MESSAGES_WINDOW, messageType,
-                                                                       getNotificationInfo().getNotificationText(), null, null);
-            }
-          }
-        };
-        ApplicationManager.getApplication().invokeLater(runnable);
       }
 
       private void stopAppIconProgress() {
@@ -334,6 +319,7 @@ public class CompilerTask extends Task.Backgroundable {
             (CompilerMessageCategory.WARNING.equals(category) && !ErrorTreeViewConfiguration.getInstance(myProject).isHideWarnings())
           );
         if (shouldAutoActivate) {
+          myMessagesAutoActivated = true;
           activateMessageView();
         }
       }
@@ -458,7 +444,7 @@ public class CompilerTask extends Task.Backgroundable {
       if (myErrorTreeView != null) {
         final ToolWindow tw = ToolWindowManager.getInstance(myProject).getToolWindow(ToolWindowId.MESSAGES_WINDOW);
         if (tw != null) {
-          myMessagesAutoActivated = tw.activate(null, false, false, false);
+          tw.activate(null, false);
         }
       }
     }
diff --git a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
index c3018d5fe9f9..c044e5b8c97b 100644
--- a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
@@ -342,7 +342,7 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
         // mark the window as "last activated" windows and thus
         // some action like navigation up/down in stactrace wont
         // work correctly
-        window.activate(null, false, false, false);
+        window.activate(null, false, false);
       }
     });
   }
diff --git a/platform/platform-api/src/com/intellij/openapi/wm/ToolWindow.java b/platform/platform-api/src/com/intellij/openapi/wm/ToolWindow.java
index 07b36ea15aa5..93870283c6ce 100644
--- a/platform/platform-api/src/com/intellij/openapi/wm/ToolWindow.java
+++ b/platform/platform-api/src/com/intellij/openapi/wm/ToolWindow.java
@@ -46,13 +46,6 @@ public interface ToolWindow extends BusyObject {
 
   void activate(@Nullable Runnable runnable, boolean autoFocusContents, boolean forced);
 
-  /**
-   * @param ignoreActiveWindowWithSameAnchor is <code>true</code> by default.
-   * If it's <code>false</code> and current active window has same anchor, activation will be cancelled
-   * @return <code>false</code> if activation was cancelled, otherwise <code>true</code>
-   */
-  boolean activate(@Nullable Runnable runnable, boolean autoFocusContents, boolean forced, boolean ignoreActiveWindowWithSameAnchor);
-
   /**
    * @return whether the tool window is visible or not.
    * @exception IllegalStateException if tool window isn't installed.
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowHeadlessManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowHeadlessManagerImpl.java
index 032c1542ec71..1f54b2bb341a 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowHeadlessManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowHeadlessManagerImpl.java
@@ -212,11 +212,6 @@ public class ToolWindowHeadlessManagerImpl extends ToolWindowManagerEx {
     public void activate(@Nullable Runnable runnable, boolean autoFocusContents, boolean forced) {
     }
 
-    @Override
-    public boolean activate(@Nullable Runnable runnable, boolean autoFocusContents, boolean forced, boolean ignoreActiveWindowWithSameAnchor) {
-      return true;
-    }
-
     @Override
     public void showContentPopup(InputEvent inputEvent) {
     }
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowImpl.java
index 61c49e0657ad..96458475d254 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowImpl.java
@@ -126,18 +126,8 @@ public final class ToolWindowImpl implements ToolWindowEx {
   }
 
   public void activate(@Nullable final Runnable runnable, boolean autoFocusContents, boolean forced) {
-    activate(runnable, autoFocusContents, forced, true);
-  }
-
-  @Override
-  public boolean activate(@Nullable final Runnable runnable, boolean autoFocusContents, boolean forced, boolean ignoreActiveWindowWithSameAnchor) {
     ApplicationManager.getApplication().assertIsDispatchThread();
-    if (!ignoreActiveWindowWithSameAnchor) {
-      String windowId = myToolWindowManager.getActiveToolWindowId();
-      if (windowId != null && windowId != myId && myToolWindowManager.getToolWindowAnchor(windowId) == getAnchor()) {
-        return false;
-      }
-    }
+
     final UiActivity activity = new UiActivity.Focus("toolWindow:" + myId);
     UiActivityMonitor.getInstance().addActivity(myToolWindowManager.getProject(), activity, ModalityState.NON_MODAL);
 
@@ -156,7 +146,6 @@ public final class ToolWindowImpl implements ToolWindowEx {
         });
       }
     });
-    return true;
   }
 
   public final boolean isActive() {

From fed00071afb2c1e7928b9954f179f8f373ff4e54 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Fri, 22 Feb 2013 15:20:07 +0400
Subject: [PATCH 047/354] toString

---
 .../plugins/groovy/lang/resolve/DeclarationCacheKey.java    | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
index f572fc37de16..a21ab1256c74 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -180,6 +180,10 @@ class DeclarationCacheKey {
       return true;
     }
 
+    @Override
+    public String toString() {
+      return "[scope=" + scope.toString() + ", plain=" + plainDeclarations.size() + ", nonCode=" + nonCodeDeclarations.size();
+    }
   }
 
   private class MyCollectProcessor extends ResolverProcessor {

From 6cece786ce8a12863ee3f76b3f6e50b02f9a18cd Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Fri, 22 Feb 2013 16:16:27 +0400
Subject: [PATCH 048/354] IDEA-99663 Groovy: method inlining with parameters of
 same package type

---
 .../inline/GroovyInlineMethodUtil.java        |  9 ++++----
 .../inline/GroovyMethodInliner.java           |  2 +-
 .../inline/InlineMethodTest.groovy            |  4 ++++
 .../typeParameterDeclaredInFile.test          | 23 +++++++++++++++++++
 4 files changed, 32 insertions(+), 6 deletions(-)
 create mode 100644 plugins/groovy/testdata/groovy/refactoring/inlineMethod/typeParameterDeclaredInFile.test

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyInlineMethodUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyInlineMethodUtil.java
index 57a0d49fa041..72ee582fa409 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyInlineMethodUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyInlineMethodUtil.java
@@ -16,7 +16,7 @@
 
 package org.jetbrains.plugins.groovy.refactoring.inline;
 
-import com.intellij.codeInsight.TargetElementUtil;
+import com.intellij.codeInsight.TargetElementUtilBase;
 import com.intellij.lang.refactoring.InlineHandler;
 import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
@@ -25,7 +25,7 @@ import com.intellij.openapi.help.HelpManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.wm.WindowManager;
 import com.intellij.psi.*;
-import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.HelpID;
@@ -81,7 +81,7 @@ public class GroovyInlineMethodUtil {
     }
 
     if (invokedOnReference) {
-      PsiReference reference = editor != null ? TargetElementUtil.findReference(editor, editor.getCaretModel().getOffset()) : null;
+      PsiReference reference = editor != null ? TargetElementUtilBase.findReference(editor, editor.getCaretModel().getOffset()) : null;
       if (reference == null) return InlineHandler.Settings.CANNOT_INLINE_SETTINGS;
 
       PsiElement element = reference.getElement();
@@ -534,8 +534,7 @@ public class GroovyInlineMethodUtil {
                                                           GrCallExpression call,
                                                           GrExpression oldExpression,
                                                           GrParameter parameter) {
-    Collection<PsiReference> refs =
-      ReferencesSearch.search(parameter, GlobalSearchScope.projectScope(parameter.getProject()), false).findAll();
+    Collection<PsiReference> refs = ReferencesSearch.search(parameter, new LocalSearchScope(method), false).findAll();
 
     final GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(call.getProject());
     GrExpression expression = elementFactory.createExpressionFromText(oldExpression.getText());
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyMethodInliner.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyMethodInliner.java
index 46c7daca121a..5e76f0c6fcbe 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyMethodInliner.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/inline/GroovyMethodInliner.java
@@ -352,7 +352,7 @@ public class GroovyMethodInliner implements InlineHandler.Inliner {
       method = ((GrReflectedMethod)method).getBaseMethod();
     }
 
-    GrMethod newMethod = factory.createMethodFromText(method.getText());
+    GrMethod newMethod = factory.createMethodFromText(method.getText(), call);
     if (qualifier != null) {
       Collection<GroovyInlineMethodUtil.ReferenceExpressionInfo> infos = GroovyInlineMethodUtil.collectReferenceInfo(method);
       GroovyInlineMethodUtil.addQualifiersToInnerReferences(newMethod, infos, qualifier);
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/inline/InlineMethodTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/inline/InlineMethodTest.groovy
index b2fec60e65ca..1c2d29c5979b 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/inline/InlineMethodTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/inline/InlineMethodTest.groovy
@@ -100,6 +100,10 @@ public class InlineMethodTest extends LightCodeInsightFixtureTestCase {
 
   public void testVarargs() {doTest();}
 
+  public void testTypeParameterDeclaredInFile() {
+    doTest()
+  }
+
   public void testInlineAll() {
     doTest(new GroovyInlineHandler() {
       @Override
diff --git a/plugins/groovy/testdata/groovy/refactoring/inlineMethod/typeParameterDeclaredInFile.test b/plugins/groovy/testdata/groovy/refactoring/inlineMethod/typeParameterDeclaredInFile.test
new file mode 100644
index 000000000000..ffeec3422041
--- /dev/null
+++ b/plugins/groovy/testdata/groovy/refactoring/inlineMethod/typeParameterDeclaredInFile.test
@@ -0,0 +1,23 @@
+class X {
+    interface GrAnnotation {}
+
+    static void getResolvedAnnotations(GrAnnotation annotation) {
+        <selection>coll</selection>(annotation)
+    }
+
+    static void coll(GrAnnotation alias) {
+        alias
+    }
+}
+-----
+class X {
+    interface GrAnnotation {}
+
+    static void getResolvedAnnotations(GrAnnotation annotation) {
+        annotation
+    }
+
+    static void coll(GrAnnotation alias) {
+        alias
+    }
+}
\ No newline at end of file

From e5c847486d31570ccccf7fdf00ec2c714e40ab47 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 13:46:23 +0100
Subject: [PATCH 049/354] a doc for MinusculeMatcher.HARD_SEPARATORS

---
 .../util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
index c2e19bfbddcf..13e9390dee12 100644
--- a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
+++ b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
@@ -31,6 +31,10 @@ import java.util.Iterator;
 * @author peter
 */
 public class MinusculeMatcher implements Matcher {
+  /**
+   * Lowercase humps don't work for parts separated by these characters
+   * Need either an explicit uppercase letter or the same separator character in prefix
+   */
   private static final String HARD_SEPARATORS = " ()";
   private ThreadLocal<MatchingState> myMatchingState = new ThreadLocal<MatchingState>() {
     @Override

From 91f97dd5026b28afb623d084ad58869de698ee92 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 14:04:49 +0100
Subject: [PATCH 050/354] allow middle matches only with 3 typed prefix letters

---
 .../testSrc/com/intellij/psi/util/NameUtilTest.java       | 8 ++++++++
 .../src/com/intellij/psi/codeStyle/MinusculeMatcher.java  | 4 ++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java b/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
index 620445235846..61c6fad606d2 100644
--- a/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/psi/util/NameUtilTest.java
@@ -256,8 +256,16 @@ public class NameUtilTest extends UsefulTestCase {
     assertMatches("*f", "reformat");
     assertMatches("*f", "reformatCode");
     assertDoesntMatch("*fc", "reformatCode");
+    assertDoesntMatch("*foc", "reformatCode");
+    assertMatches("*forc", "reformatCode");
     assertDoesntMatch("*sTC", "LazyClassTypeConstructor");
     assertDoesntMatch("*Icon", "LEADING_CONSTRUCTOR");
+    assertMatches("*I", "LEADING_CONSTRUCTOR");
+    assertMatches("*i", "LEADING_CONSTRUCTOR");
+    assertMatches("*in", "LEADING_CONSTRUCTOR");
+    assertMatches("*ing", "LEADING_CONSTRUCTOR");
+    assertDoesntMatch("*inc", "LEADING_CONSTRUCTOR");
+    assertDoesntMatch("*ico", "drawLinePickedOut");
   }
 
   public void testMiddleMatchingUnderscore() {
diff --git a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
index 13e9390dee12..4cce0d8105f1 100644
--- a/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
+++ b/platform/util/src/com/intellij/psi/codeStyle/MinusculeMatcher.java
@@ -303,10 +303,10 @@ public class MinusculeMatcher implements Matcher {
       return null;
     }
 
-    // middle matches have to be at least of length 2, to prevent too many irrelevant matches
+    // middle matches have to be at least of length 3, to prevent too many irrelevant matches
     int minFragment = isPatternChar(patternIndex - 1, '*') && !isWildcard(patternIndex + 1) &&
                       Character.isLetterOrDigit(name.charAt(nameIndex)) && !NameUtil.isWordStart(name, nameIndex)
-                      ? 2 : 1;
+                      ? 3 : 1;
     int i = 1;
     boolean ignoreCase = myOptions != NameUtil.MatchingCaseSensitivity.ALL;
     while (nameIndex + i < name.length() &&

From 9e6562fbd06b900bf324d697af159fd349bb555e Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Fri, 22 Feb 2013 18:22:17 +0400
Subject: [PATCH 051/354] Emmet support   - auto insert vendor prefixes   -
 configurable for emmet

---
 .../src/messages/XmlBundle.properties         |   9 +-
 .../src/META-INF/XmlPlugin.xml                |   6 +
 .../options/editor/WebEditorOptions.java      |  16 +-
 .../options/editor/WebEditorOptionsForm.form  |  37 +--
 .../editor/WebEditorOptionsProvider.java      |  48 +---
 .../emmet/CssEditPrefixesListPanel.java       | 190 +++++++++++++++
 .../application/options/emmet/CssPrefix.java  |  34 +++
 .../options/emmet/CssPrefixInfo.java          | 116 ++++++++++
 .../options/emmet/EmmetConfigurable.form      |  89 ++++++++
 .../options/emmet/EmmetConfigurable.java      | 181 +++++++++++++++
 .../emmet/EmmetConfigurableProvider.java      |  32 +++
 .../options/emmet/EmmetOptions.java           | 169 ++++++++++++++
 .../options/emmet/emmet_default_options.xml   | 216 ++++++++++++++++++
 .../template/emmet/ZenCodingTemplate.java     |   8 +-
 .../emmet/filters/BemEmmetFilter.java         |   3 +-
 .../com/intellij/xml/util/ColorIconCache.java |   2 -
 16 files changed, 1060 insertions(+), 96 deletions(-)
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/CssEditPrefixesListPanel.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/CssPrefix.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.form
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurableProvider.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/EmmetOptions.java
 create mode 100644 xml/impl/src/com/intellij/application/options/emmet/emmet_default_options.xml

diff --git a/platform/platform-resources-en/src/messages/XmlBundle.properties b/platform/platform-resources-en/src/messages/XmlBundle.properties
index 04ed0e5f9dbe..5bb5b5d3f3ba 100644
--- a/platform/platform-resources-en/src/messages/XmlBundle.properties
+++ b/platform/platform-resources-en/src/messages/XmlBundle.properties
@@ -241,10 +241,15 @@ label.text.path.to.profiles.ini=Path to \"profiles.ini\":
 label.text.profile=&Profile:
 button.text.settings=Settings...
 display.name.firefox.settings=Firefox Settings
-zen.coding.title=XML Zen Coding
-zen.coding.enable.label=Enable Zen Coding
+
+zen.coding.title=Emmet (XML Zen Coding)
+emmet.configuration.title=Emmet (Zen Coding)
+emmet.auto.insert.vendor.prefixes=Auto insert css vendor prefixes
+zen.coding.enable.label=Enable Emmet
+emmet.enable.bem.filter=Enable BEM filter by default
 zen.coding.enter.abbreviation.dialog.label=Please enter an abbreviation
 zen.coding.incorrect.abbreviation.error=Incorrect abbreviation
+
 title.cannot.create.html.file=Cannot create HTML file
 new.html.file.action=HTML File
 new.html.file.action.description=Creates new HTML file
diff --git a/platform/platform-resources/src/META-INF/XmlPlugin.xml b/platform/platform-resources/src/META-INF/XmlPlugin.xml
index 6cd517927f37..e0eb126d1335 100644
--- a/platform/platform-resources/src/META-INF/XmlPlugin.xml
+++ b/platform/platform-resources/src/META-INF/XmlPlugin.xml
@@ -149,6 +149,12 @@
                         serviceImplementation="com.intellij.application.options.editor.WebEditorOptions"/>
     <exportable serviceInterface="com.intellij.application.options.editor.WebEditorOptions"/>
 
+    <applicationConfigurable provider="com.intellij.application.options.emmet.EmmetConfigurableProvider"/>
+    <applicationService serviceInterface="com.intellij.application.options.emmet.EmmetOptions"
+                        serviceImplementation="com.intellij.application.options.emmet.EmmetOptions"/>
+    <exportable serviceInterface="com.intellij.application.options.emmet.EmmetOptions"/>
+
+
     <applicationService serviceInterface="com.intellij.application.options.editor.XmlFoldingSettings"
                         serviceImplementation="com.intellij.application.options.editor.XmlFoldingSettings"/>
 
diff --git a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptions.java b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptions.java
index 570014aba157..fa1f6491e172 100644
--- a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptions.java
+++ b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptions.java
@@ -109,18 +109,22 @@ public class WebEditorOptions implements PersistentStateComponent<WebEditorOptio
     myAutomaticallyInsertRequiredAttributes = automaticallyInsertRequiredAttributes;
   }
 
+  /**
+   * @deprecated use {@link com.intellij.application.options.emmet.EmmetOptions#getEmmetExpandShortcut()}
+   */
+  @Deprecated
   public int getZenCodingExpandShortcut() {
     return myZenCodingExpandShortcut;
   }
 
-  public void setZenCodingExpandShortcut(int zenCodingExpandShortcut) {
-    myZenCodingExpandShortcut = zenCodingExpandShortcut;
-  }
-
   public boolean isAutomaticallyStartAttribute() {
     return myAutomaticallyStartAttribute;
   }
 
+  /**
+   * @deprecated use {@link com.intellij.application.options.emmet.EmmetOptions#isEmmetEnabled()}
+   */
+  @Deprecated
   public boolean isZenCodingEnabled() {
     return myZenCodingEnabled;
   }
@@ -129,10 +133,6 @@ public class WebEditorOptions implements PersistentStateComponent<WebEditorOptio
     myAutomaticallyStartAttribute = automaticallyStartAttribute;
   }
 
-  public void setZenCodingEnabled(boolean zenCodingEnabled) {
-    myZenCodingEnabled = zenCodingEnabled;
-  }
-
   public boolean isAutomaticallyInsertRequiredSubTags() {
     return myAutomaticallyInsertRequiredSubTags;
   }
diff --git a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsForm.form b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsForm.form
index 0030a84058ef..920e84671bd0 100644
--- a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsForm.form
+++ b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsForm.form
@@ -8,7 +8,7 @@
     <properties/>
     <border type="none"/>
     <children>
-      <grid id="247ce" layout-manager="GridLayoutManager" row-count="6" column-count="3" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+      <grid id="247ce" layout-manager="GridLayoutManager" row-count="4" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
         <margin top="0" left="0" bottom="0" right="0"/>
         <constraints>
           <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="3" hsize-policy="3" anchor="8" fill="2" indent="0" use-parent-layout="false"/>
@@ -21,7 +21,7 @@
         <children>
           <component id="f6c8c" class="javax.swing.JCheckBox" binding="myAutomaticallyInsertClosingTagCheckBox" default-binding="true">
             <constraints>
-              <grid row="0" column="0" row-span="1" col-span="3" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+              <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
             </constraints>
             <properties>
               <text value="Automatically insert closing tag"/>
@@ -29,7 +29,7 @@
           </component>
           <component id="9f825" class="javax.swing.JCheckBox" binding="myAutomaticallyInsertRequiredAttributesCheckBox" default-binding="true">
             <constraints>
-              <grid row="1" column="0" row-span="1" col-span="3" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+              <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
             </constraints>
             <properties>
               <text value="Automatically insert required attributes"/>
@@ -37,43 +37,16 @@
           </component>
           <component id="4bf74" class="javax.swing.JCheckBox" binding="myAutomaticallyStartAttributeAfterCheckBox" default-binding="true">
             <constraints>
-              <grid row="3" column="0" row-span="1" col-span="3" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+              <grid row="3" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
             </constraints>
             <properties>
               <selected value="false"/>
               <text value="Automatically start attribute"/>
             </properties>
           </component>
-          <component id="ba426" class="javax.swing.JCheckBox" binding="myEnableZenCodingCheckBox">
-            <constraints>
-              <grid row="4" column="0" row-span="1" col-span="3" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
-            </constraints>
-            <properties>
-              <text value="Enable Zen Coding"/>
-            </properties>
-          </component>
-          <component id="7c51c" class="javax.swing.JLabel">
-            <constraints>
-              <grid row="5" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="3" use-parent-layout="false"/>
-            </constraints>
-            <properties>
-              <text value="Expand abbreviation with"/>
-            </properties>
-          </component>
-          <component id="ed567" class="javax.swing.JComboBox" binding="myZenCodingExpandShortcutCombo">
-            <constraints>
-              <grid row="5" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="2" anchor="8" fill="1" indent="0" use-parent-layout="false"/>
-            </constraints>
-            <properties/>
-          </component>
-          <hspacer id="8ee6f">
-            <constraints>
-              <grid row="5" column="2" row-span="1" col-span="1" vsize-policy="1" hsize-policy="6" anchor="0" fill="1" indent="0" use-parent-layout="false"/>
-            </constraints>
-          </hspacer>
           <component id="c21d3" class="javax.swing.JCheckBox" binding="myAutomaticallyInsertRequiredSubTagsCheckBox" default-binding="true">
             <constraints>
-              <grid row="2" column="0" row-span="1" col-span="3" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+              <grid row="2" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
             </constraints>
             <properties>
               <text value="Automatically insert required subtags"/>
diff --git a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsProvider.java b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsProvider.java
index eb1ff2ad95f6..da7f38ae0428 100644
--- a/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsProvider.java
+++ b/xml/impl/src/com/intellij/application/options/editor/WebEditorOptionsProvider.java
@@ -15,15 +15,11 @@
  */
 package com.intellij.application.options.editor;
 
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.template.impl.TemplateSettings;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.xml.XmlBundle;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
 
 /**
  * @author spleaner
@@ -34,23 +30,7 @@ public class WebEditorOptionsProvider implements EditorOptionsProvider {
   private JCheckBox myAutomaticallyInsertRequiredAttributesCheckBox;
   private JCheckBox myAutomaticallyInsertRequiredSubTagsCheckBox;
   private JCheckBox myAutomaticallyStartAttributeAfterCheckBox;
-  private JCheckBox myEnableZenCodingCheckBox;
-  private JComboBox myZenCodingExpandShortcutCombo;
 
-  private static final String SPACE = CodeInsightBundle.message("template.shortcut.space");
-  private static final String TAB = CodeInsightBundle.message("template.shortcut.tab");
-  private static final String ENTER = CodeInsightBundle.message("template.shortcut.enter");
-
-  {
-    myZenCodingExpandShortcutCombo.addItem(SPACE);
-    myZenCodingExpandShortcutCombo.addItem(TAB);
-    myZenCodingExpandShortcutCombo.addItem(ENTER);
-    myEnableZenCodingCheckBox.addActionListener(new ActionListener() {
-      public void actionPerformed(ActionEvent e) {
-        myZenCodingExpandShortcutCombo.setEnabled(myEnableZenCodingCheckBox.isSelected());
-      }
-    });
-  }
 
   public String getDisplayName() {
     return XmlBundle.message("web.editor.configuration.title");
@@ -64,24 +44,13 @@ public class WebEditorOptionsProvider implements EditorOptionsProvider {
     return myWholePanel;
   }
 
-  private char getSelectedZenCodingExpandShortcut() {
-    Object selectedItem = myZenCodingExpandShortcutCombo.getSelectedItem();
-    if (TAB.equals(selectedItem)) {
-      return TemplateSettings.TAB_CHAR;
-    }
-    else if (ENTER.equals(selectedItem)) {
-      return TemplateSettings.ENTER_CHAR;
-    }
-    return TemplateSettings.SPACE_CHAR;
-  }
+
 
   public boolean isModified() {
     final WebEditorOptions xmlEditorOptions = WebEditorOptions.getInstance();
     return xmlEditorOptions.isAutomaticallyInsertClosingTag() != myAutomaticallyInsertClosingTagCheckBox.isSelected() ||
            xmlEditorOptions.isAutomaticallyInsertRequiredAttributes() != myAutomaticallyInsertRequiredAttributesCheckBox.isSelected() ||
            xmlEditorOptions.isAutomaticallyStartAttribute() != myAutomaticallyStartAttributeAfterCheckBox.isSelected() ||
-           xmlEditorOptions.isZenCodingEnabled() != myEnableZenCodingCheckBox.isSelected() ||
-           xmlEditorOptions.getZenCodingExpandShortcut() != getSelectedZenCodingExpandShortcut() ||
            xmlEditorOptions.isAutomaticallyInsertRequiredSubTags() != myAutomaticallyInsertRequiredSubTagsCheckBox.isSelected();
   }
 
@@ -91,8 +60,6 @@ public class WebEditorOptionsProvider implements EditorOptionsProvider {
     xmlEditorOptions.setAutomaticallyInsertRequiredAttributes(myAutomaticallyInsertRequiredAttributesCheckBox.isSelected());
     xmlEditorOptions.setAutomaticallyInsertRequiredSubTags(myAutomaticallyInsertRequiredSubTagsCheckBox.isSelected());
     xmlEditorOptions.setAutomaticallyStartAttribute(myAutomaticallyStartAttributeAfterCheckBox.isSelected());
-    xmlEditorOptions.setZenCodingEnabled(myEnableZenCodingCheckBox.isSelected());
-    xmlEditorOptions.setZenCodingExpandShortcut(getSelectedZenCodingExpandShortcut());
   }
 
   public void reset() {
@@ -101,19 +68,6 @@ public class WebEditorOptionsProvider implements EditorOptionsProvider {
     myAutomaticallyInsertRequiredAttributesCheckBox.setSelected(xmlEditorOptions.isAutomaticallyInsertRequiredAttributes());
     myAutomaticallyInsertRequiredSubTagsCheckBox.setSelected(xmlEditorOptions.isAutomaticallyInsertRequiredSubTags());
     myAutomaticallyStartAttributeAfterCheckBox.setSelected(xmlEditorOptions.isAutomaticallyStartAttribute());
-    myEnableZenCodingCheckBox.setSelected(xmlEditorOptions.isZenCodingEnabled());
-    myZenCodingExpandShortcutCombo.setEnabled(xmlEditorOptions.isZenCodingEnabled());
-
-    char shortcut = (char)WebEditorOptions.getInstance().getZenCodingExpandShortcut();
-    if (shortcut == TemplateSettings.TAB_CHAR) {
-      myZenCodingExpandShortcutCombo.setSelectedItem(TAB);
-    }
-    else if (shortcut == TemplateSettings.ENTER_CHAR) {
-      myZenCodingExpandShortcutCombo.setSelectedItem(ENTER);
-    }
-    else {
-      myZenCodingExpandShortcutCombo.setSelectedItem(SPACE);
-    }
   }
 
   public void disposeUIResources() {
diff --git a/xml/impl/src/com/intellij/application/options/emmet/CssEditPrefixesListPanel.java b/xml/impl/src/com/intellij/application/options/emmet/CssEditPrefixesListPanel.java
new file mode 100644
index 000000000000..aa6d6ec5620d
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/CssEditPrefixesListPanel.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+import com.intellij.openapi.ui.Messages;
+import com.intellij.ui.*;
+import com.intellij.ui.components.JBCheckBox;
+import com.intellij.ui.table.TableView;
+import com.intellij.util.ui.ColumnInfo;
+import com.intellij.util.ui.ListTableModel;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import javax.swing.table.TableCellEditor;
+import javax.swing.table.TableCellRenderer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: zolotov
+ * Date: 2/20/13
+ */
+public class CssEditPrefixesListPanel {
+  private final ListTableModel<CssPrefixInfo> myPrefixesModel;
+  private final TableView<CssPrefixInfo> myPrefixesTableView;
+
+  public CssEditPrefixesListPanel() {
+    ColumnInfo[] columns = new ColumnInfo[CssPrefix.values().length + 1];
+    columns[0] = new PropertyColumn();
+    CssPrefix[] values = CssPrefix.values();
+    for (int i = 0; i < values.length; i++) {
+      columns[i + 1] = new PrefixColumnInfo(values[i]);
+    }
+
+    myPrefixesModel = new ListTableModel<CssPrefixInfo>(columns, new ArrayList<CssPrefixInfo>(), 0);
+    myPrefixesModel.setSortable(true);
+    myPrefixesTableView = new TableView<CssPrefixInfo>(myPrefixesModel);
+    myPrefixesTableView.setAutoCreateRowSorter(true);
+    myPrefixesTableView.setBorder(null);
+    myPrefixesTableView.getRowSorter().toggleSortOrder(0);
+
+    new TableViewSpeedSearch(myPrefixesTableView) {
+      @Override
+      protected String getElementText(final Object element) {
+        CssPrefixInfo prefixInfo = (CssPrefixInfo)element;
+        return prefixInfo.getPropertyName();
+      }
+    };
+  }
+
+  public void setEnabled(boolean value) {
+    myPrefixesTableView.setEnabled(value);
+  }
+
+  public void setState(List<CssPrefixInfo> prefixInfos) {
+    myPrefixesModel.setItems(prefixInfos);
+  }
+
+  public List<CssPrefixInfo> getState() {
+    return myPrefixesModel.getItems();
+  }
+
+  public JPanel createMainComponent() {
+    final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myPrefixesTableView);
+    decorator.disableUpDownActions();
+    final JPanel panel = decorator.createPanel();
+    decorator.setAddAction(new AnActionButtonRunnable() {
+      @Override
+      public void run(AnActionButton button) {
+        TableUtil.stopEditing(myPrefixesTableView);
+        String propertyName = Messages.showInputDialog(myPrefixesTableView, "Property name:", "New Css Property", null);
+        if (propertyName != null && !propertyName.isEmpty()) {
+          List<CssPrefixInfo> items = myPrefixesModel.getItems();
+          for (CssPrefixInfo state : items) {
+            if (propertyName.equals(state.getPropertyName())) {
+              myPrefixesTableView.clearSelection();
+              myPrefixesTableView.addSelection(state);
+              scrollToSelection();
+              return;
+            }
+          }
+          CssPrefixInfo newPrefixInfo = new CssPrefixInfo(propertyName);
+          myPrefixesModel.addRow(newPrefixInfo);
+          myPrefixesTableView.clearSelection();
+          myPrefixesTableView.addSelection(newPrefixInfo);
+          scrollToSelection();
+        }
+        myPrefixesTableView.requestFocus();
+      }
+
+      private void scrollToSelection() {
+        int selectedRow = myPrefixesTableView.getSelectedRow();
+        if (selectedRow >= 0) {
+          myPrefixesTableView.scrollRectToVisible(myPrefixesTableView.getCellRect(selectedRow, 0, true));
+        }
+      }
+    }).setRemoveAction(new AnActionButtonRunnable() {
+      @Override
+      public void run(AnActionButton button) {
+        TableUtil.stopEditing(myPrefixesTableView);
+        CssPrefixInfo selectedObject = myPrefixesTableView.getSelectedObject();
+        int selectedRow = myPrefixesTableView.getSelectedRow();
+        int index = myPrefixesModel.indexOf(selectedObject);
+        if (0 <= index && index < myPrefixesModel.getRowCount()) {
+          myPrefixesModel.removeRow(index);
+          if (selectedRow < myPrefixesTableView.getRowCount()) {
+            myPrefixesTableView.setRowSelectionInterval(selectedRow, selectedRow);
+          }
+          else {
+            if (selectedRow > 0) {
+              myPrefixesTableView.setRowSelectionInterval(selectedRow - 1, selectedRow - 1);
+            }
+          }
+        }
+        myPrefixesTableView.getParent().repaint();
+        myPrefixesTableView.requestFocus();
+      }
+    });
+    return panel;
+  }
+
+  private static class PropertyColumn extends ColumnInfo<CssPrefixInfo, String> {
+    public PropertyColumn() {
+      super("Property");
+    }
+
+    @Nullable
+    @Override
+    public String valueOf(CssPrefixInfo prefixInfo) {
+      return prefixInfo.getPropertyName();
+    }
+  }
+
+  private class PrefixColumnInfo extends ColumnInfo<CssPrefixInfo, Boolean> {
+    private final CssPrefix myPrefix;
+    private final BooleanTableCellRenderer myCellRenderer = new BooleanTableCellRenderer();
+
+    @Nullable
+    @Override
+    public TableCellRenderer getRenderer(CssPrefixInfo state) {
+      return myCellRenderer;
+    }
+
+    public PrefixColumnInfo(CssPrefix prefix) {
+      super(prefix.getText());
+      myPrefix = prefix;
+    }
+
+    @Nullable
+    @Override
+    public TableCellEditor getEditor(CssPrefixInfo prefixInfo) {
+      JBCheckBox box = new JBCheckBox();
+      box.setHorizontalAlignment(SwingConstants.CENTER);
+      return new DefaultCellEditor(box);
+    }
+
+    @Override
+    public boolean isCellEditable(CssPrefixInfo prefixInfo) {
+      return myPrefixesTableView.isEnabled();
+    }
+
+    public final Class<Boolean> getColumnClass() {
+      return Boolean.class;
+    }
+
+    @Override
+    public final void setValue(final CssPrefixInfo prefixInfo, final Boolean aValue) {
+      prefixInfo.setValue(myPrefix, aValue);
+    }
+
+    @Nullable
+    @Override
+    public final Boolean valueOf(CssPrefixInfo state) {
+      return state.getValue(myPrefix);
+    }
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/CssPrefix.java b/xml/impl/src/com/intellij/application/options/emmet/CssPrefix.java
new file mode 100644
index 000000000000..da3bae3ab476
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/CssPrefix.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+/**
+* User: zolotov
+* Date: 2/21/13
+*/
+public enum CssPrefix {
+  WEBKIT(0x1), MOZ(0x2), MS(0x4), O(0x8);
+
+  final int myIntMask;
+
+  CssPrefix(int intMask) {
+    myIntMask = intMask;
+  }
+
+  public String getText() {
+    return "-" + toString().toLowerCase();
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java b/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
new file mode 100644
index 000000000000..f31443ce9e4b
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Sets.newHashSet;
+
+/**
+ * User: zolotov
+ * Date: 2/20/13
+ */
+public class CssPrefixInfo {
+  @NotNull
+  private final String myPropertyName;
+  @NotNull
+  private final Collection<CssPrefix> myEnabledPrefixes;
+
+  public CssPrefixInfo(@NotNull String propertyName, CssPrefix... enabledPrefixes) {
+    myPropertyName = propertyName;
+    myEnabledPrefixes = newHashSet(enabledPrefixes);
+    for (CssPrefix prefix : enabledPrefixes) {
+      setValue(prefix, true);
+    }
+  }
+
+  public CssPrefixInfo(@NotNull String propertyName, Collection<CssPrefix> enabledPrefixes) {
+    myPropertyName = propertyName;
+    myEnabledPrefixes = newHashSet(enabledPrefixes);
+    for (CssPrefix prefix : enabledPrefixes) {
+      setValue(prefix, true);
+    }
+  }
+
+  @NotNull
+  public Collection<CssPrefix> getEnabledPrefixes() {
+    return myEnabledPrefixes;
+  }
+
+  public void setValue(CssPrefix prefix, boolean value) {
+    if (value) {
+      myEnabledPrefixes.add(prefix);
+    } else {
+      myEnabledPrefixes.remove(prefix);
+    }
+  }
+
+  public boolean getValue(CssPrefix prefix) {
+    return myEnabledPrefixes.contains(prefix);
+  }
+
+  @NotNull
+  public String getPropertyName() {
+    return myPropertyName;
+  }
+
+  public static CssPrefixInfo fromIntegerValue(String propertyName, Integer value) {
+    if (value == null) {
+      return new CssPrefixInfo(propertyName);
+    }
+    List<CssPrefix> enabledPrefixes = newArrayList();
+    for (CssPrefix prefix : CssPrefix.values()) {
+      if ((value & prefix.myIntMask) > 0) {
+        enabledPrefixes.add(prefix);
+      }
+    }
+    return new CssPrefixInfo(propertyName, enabledPrefixes);
+  }
+
+  public int toIntegerValue() {
+    int result = 0;
+    for (CssPrefix prefix : myEnabledPrefixes) {
+      if (getValue(prefix)) {
+        result |= prefix.myIntMask;
+      }
+    }
+    return result;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    CssPrefixInfo that = (CssPrefixInfo)o;
+
+    if (!myEnabledPrefixes.equals(that.myEnabledPrefixes)) return false;
+    if (!myPropertyName.equals(that.myPropertyName)) return false;
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = myPropertyName.hashCode();
+    result = 31 * result + myEnabledPrefixes.hashCode();
+    return result;
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.form b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.form
new file mode 100644
index 000000000000..62127bcf42e3
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.form
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="com.intellij.application.options.emmet.EmmetConfigurable">
+  <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="4" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+    <margin top="0" left="0" bottom="0" right="0"/>
+    <constraints>
+      <xy x="20" y="20" width="500" height="400"/>
+    </constraints>
+    <properties/>
+    <border type="none"/>
+    <children>
+      <component id="446a3" class="com.intellij.ui.components.JBCheckBox" binding="myEnableEmmetJBCheckBox" default-binding="true">
+        <constraints>
+          <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text resource-bundle="messages/XmlBundle" key="zen.coding.enable.label"/>
+        </properties>
+      </component>
+      <component id="c71a" class="com.intellij.ui.components.JBLabel">
+        <constraints>
+          <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="1" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <labelFor value="ce319"/>
+          <text value="Expand abbreviation with"/>
+        </properties>
+      </component>
+      <component id="59f5a" class="javax.swing.JComboBox" binding="myEmmetExpandShortcutCombo">
+        <constraints>
+          <grid row="1" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="6" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <model/>
+        </properties>
+      </component>
+      <grid id="369dc" layout-manager="GridLayoutManager" row-count="1" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+        <margin top="0" left="0" bottom="0" right="0"/>
+        <constraints>
+          <grid row="2" column="0" row-span="1" col-span="2" vsize-policy="1" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+        <clientProperties>
+          <BorderFactoryClass class="java.lang.String" value="com.intellij.ui.IdeBorderFactory$PlainSmallWithIndent"/>
+        </clientProperties>
+        <border type="none" title="XML"/>
+        <children>
+          <component id="9ed4c" class="com.intellij.ui.components.JBCheckBox" binding="myEnableBEMFilterJBCheckBox" default-binding="true">
+            <constraints>
+              <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="9" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <text resource-bundle="messages/XmlBundle" key="emmet.enable.bem.filter"/>
+            </properties>
+          </component>
+        </children>
+      </grid>
+      <grid id="bd64d" layout-manager="GridLayoutManager" row-count="2" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+        <margin top="0" left="0" bottom="0" right="0"/>
+        <constraints>
+          <grid row="3" column="0" row-span="1" col-span="2" vsize-policy="3" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties/>
+        <clientProperties>
+          <BorderFactoryClass class="java.lang.String" value="com.intellij.ui.IdeBorderFactory$PlainSmallWithIndent"/>
+        </clientProperties>
+        <border type="none" title="CSS"/>
+        <children>
+          <component id="65354" class="com.intellij.ui.components.JBCheckBox" binding="myAutoInsertCssVendorJBCheckBox" default-binding="true">
+            <constraints>
+              <grid row="0" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties>
+              <text resource-bundle="messages/XmlBundle" key="emmet.auto.insert.vendor.prefixes"/>
+            </properties>
+          </component>
+          <grid id="612b" binding="myPrefixesPanel" custom-create="true" layout-manager="GridLayoutManager" row-count="1" column-count="1" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+            <margin top="0" left="0" bottom="0" right="0"/>
+            <constraints>
+              <grid row="1" column="0" row-span="1" col-span="1" vsize-policy="3" hsize-policy="3" anchor="0" fill="3" indent="0" use-parent-layout="false"/>
+            </constraints>
+            <properties/>
+            <border type="none"/>
+            <children/>
+          </grid>
+        </children>
+      </grid>
+    </children>
+  </grid>
+</form>
diff --git a/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
new file mode 100644
index 000000000000..5f69489785da
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+import com.intellij.codeInsight.CodeInsightBundle;
+import com.intellij.codeInsight.template.impl.TemplateSettings;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.options.Configurable;
+import com.intellij.openapi.options.ConfigurationException;
+import com.intellij.openapi.options.SearchableConfigurable;
+import com.intellij.ui.components.JBCheckBox;
+import com.intellij.xml.XmlBundle;
+import org.jetbrains.annotations.Nls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+/**
+ * User: zolotov
+ * Date: 2/20/13
+ */
+public class EmmetConfigurable implements SearchableConfigurable, Disposable, Configurable.NoScroll {
+  private JBCheckBox myEnableEmmetJBCheckBox;
+  private JComboBox myEmmetExpandShortcutCombo;
+  private JBCheckBox myEnableBEMFilterJBCheckBox;
+  private JBCheckBox myAutoInsertCssVendorJBCheckBox;
+  private JPanel myPanel;
+  private JPanel myPrefixesPanel;
+
+  private CssEditPrefixesListPanel myCssEditPrefixesListPanel;
+
+  private static final String SPACE = CodeInsightBundle.message("template.shortcut.space");
+  private static final String TAB = CodeInsightBundle.message("template.shortcut.tab");
+  private static final String ENTER = CodeInsightBundle.message("template.shortcut.enter");
+
+  public EmmetConfigurable() {
+    myEnableEmmetJBCheckBox.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        boolean selected = myEnableEmmetJBCheckBox.isSelected();
+        myEmmetExpandShortcutCombo.setEnabled(selected);
+        //myInsertFallbackGradientColorJBCheckBox.setEnabled(selected);
+        myAutoInsertCssVendorJBCheckBox.setEnabled(selected);
+        myCssEditPrefixesListPanel.setEnabled(selected && myAutoInsertCssVendorJBCheckBox.isSelected());
+        myEnableBEMFilterJBCheckBox.setEnabled(selected);
+      }
+    });
+
+    myAutoInsertCssVendorJBCheckBox.addActionListener(new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        myCssEditPrefixesListPanel.setEnabled(myAutoInsertCssVendorJBCheckBox.isSelected());
+      }
+    });
+
+    myEmmetExpandShortcutCombo.addItem(SPACE);
+    myEmmetExpandShortcutCombo.addItem(TAB);
+    myEmmetExpandShortcutCombo.addItem(ENTER);
+  }
+
+  private char getSelectedEmmetExpandShortcut() {
+    Object selectedItem = myEmmetExpandShortcutCombo.getSelectedItem();
+    if (TAB.equals(selectedItem)) {
+      return TemplateSettings.TAB_CHAR;
+    }
+    else if (ENTER.equals(selectedItem)) {
+      return TemplateSettings.ENTER_CHAR;
+    }
+    return TemplateSettings.SPACE_CHAR;
+  }
+
+  @Override
+  public void dispose() {
+  }
+
+  @NotNull
+  @Override
+  public String getId() {
+    return "reference.settingsdialog.emmet";
+  }
+
+  @Nullable
+  @Override
+  public Runnable enableSearch(String option) {
+    return null;
+  }
+
+  @Nls
+  @Override
+  public String getDisplayName() {
+    return XmlBundle.message("emmet.configuration.title");
+  }
+
+  @Nullable
+  @Override
+  public String getHelpTopic() {
+    return getId();
+  }
+
+  @Nullable
+  @Override
+  public JComponent createComponent() {
+    return myPanel;
+  }
+
+  @Override
+  public boolean isModified() {
+    EmmetOptions emmetOptions = EmmetOptions.getInstance();
+    return emmetOptions.isEmmetEnabled() != myEnableEmmetJBCheckBox.isSelected() ||
+           emmetOptions.isBemFilterEnabledByDefault() != myEnableBEMFilterJBCheckBox.isSelected() ||
+           emmetOptions.isAutoInsertCssPrefixedEnabled() != myAutoInsertCssVendorJBCheckBox.isSelected() ||
+           !emmetOptions.getAllPrefixInfo().equals(myCssEditPrefixesListPanel.getState()) ||
+           emmetOptions.getEmmetExpandShortcut() != getSelectedEmmetExpandShortcut();
+  }
+
+
+  @Override
+  public void apply() throws ConfigurationException {
+    EmmetOptions emmetOptions = EmmetOptions.getInstance();
+    emmetOptions.setEmmetEnabled(myEnableEmmetJBCheckBox.isSelected());
+    emmetOptions.setEnableBemFilterByDefault(myEnableBEMFilterJBCheckBox.isSelected());
+    emmetOptions.setEmmetExpandShortcut(getSelectedEmmetExpandShortcut());
+    emmetOptions.setAutoInsertCssPrefixedEnabled(myAutoInsertCssVendorJBCheckBox.isSelected());
+    emmetOptions.setPrefixInfo(myCssEditPrefixesListPanel.getState());
+  }
+
+  @Override
+  public void reset() {
+    EmmetOptions emmetOptions = EmmetOptions.getInstance();
+    myEnableEmmetJBCheckBox.setSelected(emmetOptions.isEmmetEnabled());
+    myEnableBEMFilterJBCheckBox.setEnabled(emmetOptions.isEmmetEnabled());
+    myEnableBEMFilterJBCheckBox.setSelected(emmetOptions.isBemFilterEnabledByDefault());
+    myEmmetExpandShortcutCombo.setEnabled(emmetOptions.isEmmetEnabled());
+    myAutoInsertCssVendorJBCheckBox.setEnabled(emmetOptions.isEmmetEnabled());
+    myAutoInsertCssVendorJBCheckBox.setSelected(emmetOptions.isAutoInsertCssPrefixedEnabled());
+    //myInsertFallbackGradientColorJBCheckBox.setEnabled(emmetOptions.isEmmetEnabled());
+    //myInsertFallbackGradientColorJBCheckBox.setSelected(emmetOptions.isInsertFallbackGradientColorEnabled());
+
+    myCssEditPrefixesListPanel.setEnabled(emmetOptions.isEmmetEnabled() && emmetOptions.isAutoInsertCssPrefixedEnabled());
+    myCssEditPrefixesListPanel.setState(emmetOptions.getAllPrefixInfo());
+
+    char shortcut = (char)emmetOptions.getEmmetExpandShortcut();
+    if (shortcut == TemplateSettings.TAB_CHAR) {
+      myEmmetExpandShortcutCombo.setSelectedItem(TAB);
+    }
+    else if (shortcut == TemplateSettings.ENTER_CHAR) {
+      myEmmetExpandShortcutCombo.setSelectedItem(ENTER);
+    }
+    else {
+      myEmmetExpandShortcutCombo.setSelectedItem(SPACE);
+    }
+  }
+
+  @Override
+  public void disposeUIResources() {
+    myCssEditPrefixesListPanel = null;
+    myPrefixesPanel = null;
+  }
+
+  private void createUIComponents() {
+    myCssEditPrefixesListPanel = new CssEditPrefixesListPanel();
+    myPrefixesPanel = myCssEditPrefixesListPanel.createMainComponent();
+    myPrefixesPanel.setEnabled(true);
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurableProvider.java b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurableProvider.java
new file mode 100644
index 000000000000..2d13a7382516
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurableProvider.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+import com.intellij.openapi.options.Configurable;
+import com.intellij.openapi.options.ConfigurableProvider;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: zolotov
+ * Date: 2/20/13
+ */
+public class EmmetConfigurableProvider extends ConfigurableProvider {
+  @Nullable
+  @Override
+  public Configurable createConfigurable() {
+    return new EmmetConfigurable();
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/EmmetOptions.java b/xml/impl/src/com/intellij/application/options/emmet/EmmetOptions.java
new file mode 100644
index 000000000000..70ddaa453aae
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/EmmetOptions.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2000-2013 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.application.options.emmet;
+
+import com.intellij.application.options.editor.WebEditorOptions;
+import com.intellij.openapi.application.PathManager;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.JDOMUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.util.xmlb.XmlSerializerUtil;
+import com.intellij.xml.XmlBundle;
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Lists.newLinkedList;
+import static com.google.common.collect.Maps.newHashMap;
+import static com.google.common.io.Resources.getResource;
+
+/**
+ * User: zolotov
+ * Date: 2/20/13
+ */
+@State(
+  name = "EmmetOptions",
+  storages = {
+    @Storage(
+      file = StoragePathMacros.APP_CONFIG + "/emmet.xml"
+    )}
+)
+public class EmmetOptions implements PersistentStateComponent<EmmetOptions>, ExportableComponent {
+  private boolean myEnableBemFilterByDefault = false;
+  private boolean myEmmetEnabled = WebEditorOptions.getInstance().isZenCodingEnabled();
+  private int myEmmetExpandShortcut = WebEditorOptions.getInstance().getZenCodingExpandShortcut();
+  private boolean myAutoInsertCssPrefixedEnabled = true;
+  @Nullable
+  private Map<String, Integer> prefixes = null;
+
+  public void setPrefixInfo(List<CssPrefixInfo> prefixInfos) {
+    prefixes = newHashMap();
+    for (CssPrefixInfo state : prefixInfos) {
+      prefixes.put(state.getPropertyName(), state.toIntegerValue());
+    }
+  }
+
+  public CssPrefixInfo getPrefixStateForProperty(String propertyName) {
+    return CssPrefixInfo.fromIntegerValue(propertyName, getPrefixes().get(propertyName));
+  }
+
+  public List<CssPrefixInfo> getAllPrefixInfo() {
+    List<CssPrefixInfo> result = newLinkedList();
+    for (Map.Entry<String, Integer> entry : getPrefixes().entrySet()) {
+      result.add(CssPrefixInfo.fromIntegerValue(entry.getKey(), entry.getValue()));
+    }
+    return result;
+  }
+
+  public boolean isBemFilterEnabledByDefault() {
+    return myEnableBemFilterByDefault;
+  }
+
+  public void setEnableBemFilterByDefault(boolean enableBemFilterByDefault) {
+    myEnableBemFilterByDefault = enableBemFilterByDefault;
+  }
+
+  public void setEmmetExpandShortcut(int emmetExpandShortcut) {
+    myEmmetExpandShortcut = emmetExpandShortcut;
+  }
+
+  public int getEmmetExpandShortcut() {
+    return myEmmetExpandShortcut;
+  }
+
+  public boolean isEmmetEnabled() {
+    return myEmmetEnabled;
+  }
+
+  public void setEmmetEnabled(boolean emmetEnabled) {
+    myEmmetEnabled = emmetEnabled;
+  }
+
+  public boolean isAutoInsertCssPrefixedEnabled() {
+    return myAutoInsertCssPrefixedEnabled;
+  }
+
+  public void setAutoInsertCssPrefixedEnabled(boolean autoInsertCssPrefixedEnabled) {
+    myAutoInsertCssPrefixedEnabled = autoInsertCssPrefixedEnabled;
+  }
+
+  @NotNull
+  @Override
+  public File[] getExportFiles() {
+    return new File[]{PathManager.getOptionsFile("emmet")};
+  }
+
+  @NotNull
+  @Override
+  public String getPresentableName() {
+    return XmlBundle.message("emmet.configuration.title");
+  }
+
+  @Nullable
+  @Override
+  public EmmetOptions getState() {
+    return this;
+  }
+
+  public void loadState(final EmmetOptions state) {
+    XmlSerializerUtil.copyBean(state, this);
+  }
+
+  public static EmmetOptions getInstance() {
+    return ServiceManager.getService(EmmetOptions.class);
+  }
+
+  @SuppressWarnings("UnusedDeclaration")
+  @NotNull
+  public Map<String, Integer> getPrefixes() {
+    if (prefixes == null) {
+      prefixes = loadDefaultPrefixes();
+    }
+    return prefixes;
+  }
+
+  @SuppressWarnings("UnusedDeclaration")
+  public void setPrefixes(@Nullable Map<String, Integer> prefixes) {
+    this.prefixes = prefixes;
+  }
+
+  public static Map<String, Integer> loadDefaultPrefixes() {
+    Map<String, Integer> result = newHashMap();
+    try {
+      Document document = JDOMUtil.loadDocument(getResource(EmmetOptions.class, "emmet_default_options.xml"));
+      Element prefixesElement = document.getRootElement().getChild("prefixes");
+      if (prefixesElement != null) {
+        for (Object entry : prefixesElement.getChildren("entry")) {
+          Element entryElement = (Element)entry;
+          String propertyName = entryElement.getAttributeValue("key");
+          Integer value = StringUtil.parseInt(entryElement.getAttributeValue("value"), 0);
+          result.put(propertyName, value);
+        }
+      }
+    }
+    catch (Exception e) {
+      Logger.getInstance(EmmetOptions.class).warn(e);
+      return result;
+    }
+    return result;
+  }
+}
diff --git a/xml/impl/src/com/intellij/application/options/emmet/emmet_default_options.xml b/xml/impl/src/com/intellij/application/options/emmet/emmet_default_options.xml
new file mode 100644
index 000000000000..287ab5f703f3
--- /dev/null
+++ b/xml/impl/src/com/intellij/application/options/emmet/emmet_default_options.xml
@@ -0,0 +1,216 @@
+<DefaultEmmetOptions>
+  <prefixes>
+    <entry key="accelerator" value="4"/>
+    <entry key="accesskey" value="8"/>
+    <entry key="animation" value="9"/>
+    <entry key="animation-delay" value="11"/>
+    <entry key="animation-direction" value="11"/>
+    <entry key="animation-duration" value="11"/>
+    <entry key="animation-fill-mode" value="11"/>
+    <entry key="animation-iteration-count" value="11"/>
+    <entry key="animation-name" value="11"/>
+    <entry key="animation-play-state" value="11"/>
+    <entry key="animation-timing-function" value="11"/>
+    <entry key="appearance" value="3"/>
+    <entry key="backface-visibility" value="7"/>
+    <entry key="background-clip" value="3"/>
+    <entry key="background-composite" value="1"/>
+    <entry key="background-inline-policy" value="2"/>
+    <entry key="background-origin" value="1"/>
+    <entry key="background-position-x" value="4"/>
+    <entry key="background-position-y" value="4"/>
+    <entry key="background-size" value="1"/>
+    <entry key="behavior" value="4"/>
+    <entry key="binding" value="2"/>
+    <entry key="block-progression" value="4"/>
+    <entry key="border-bottom-colors" value="2"/>
+    <entry key="border-fit" value="1"/>
+    <entry key="border-horizontal-spacing" value="1"/>
+    <entry key="border-image" value="11"/>
+    <entry key="border-left-colors" value="2"/>
+    <entry key="border-radius" value="3"/>
+    <entry key="border-right-colors" value="2"/>
+    <entry key="border-top-colors" value="2"/>
+    <entry key="border-vertical-spacing" value="1"/>
+    <entry key="box-align" value="7"/>
+    <entry key="box-direction" value="7"/>
+    <entry key="box-flex" value="7"/>
+    <entry key="box-flex-group" value="1"/>
+    <entry key="box-line-progression" value="4"/>
+    <entry key="box-lines" value="5"/>
+    <entry key="box-ordinal-group" value="7"/>
+    <entry key="box-orient" value="7"/>
+    <entry key="box-pack" value="7"/>
+    <entry key="box-reflect" value="1"/>
+    <entry key="box-shadow" value="3"/>
+    <entry key="box-sizing" value="3"/>
+    <entry key="color-correction" value="1"/>
+    <entry key="column-break-after" value="1"/>
+    <entry key="column-break-before" value="1"/>
+    <entry key="column-break-inside" value="1"/>
+    <entry key="column-count" value="3"/>
+    <entry key="column-gap" value="3"/>
+    <entry key="column-rule-color" value="3"/>
+    <entry key="column-rule-style" value="3"/>
+    <entry key="column-rule-width" value="3"/>
+    <entry key="column-span" value="1"/>
+    <entry key="column-width" value="3"/>
+    <entry key="content-zoom-boundary" value="4"/>
+    <entry key="content-zoom-boundary-max" value="4"/>
+    <entry key="content-zoom-boundary-min" value="4"/>
+    <entry key="content-zoom-chaining" value="4"/>
+    <entry key="content-zoom-snap" value="4"/>
+    <entry key="content-zoom-snap-points" value="4"/>
+    <entry key="content-zoom-snap-type" value="4"/>
+    <entry key="content-zooming" value="4"/>
+    <entry key="dashboard-region" value="9"/>
+    <entry key="filter" value="4"/>
+    <entry key="float-edge" value="2"/>
+    <entry key="flow-from" value="4"/>
+    <entry key="flow-into" value="4"/>
+    <entry key="font-feature-settings" value="6"/>
+    <entry key="font-language-override" value="2"/>
+    <entry key="font-smoothing" value="1"/>
+    <entry key="force-broken-image-icon" value="2"/>
+    <entry key="grid-column" value="4"/>
+    <entry key="grid-column-align" value="4"/>
+    <entry key="grid-column-span" value="4"/>
+    <entry key="grid-columns" value="4"/>
+    <entry key="grid-layer" value="4"/>
+    <entry key="grid-row" value="4"/>
+    <entry key="grid-row-align" value="4"/>
+    <entry key="grid-row-span" value="4"/>
+    <entry key="grid-rows" value="4"/>
+    <entry key="high-contrast-adjust" value="4"/>
+    <entry key="highlight" value="1"/>
+    <entry key="hyphenate-character" value="1"/>
+    <entry key="hyphenate-limit-after" value="1"/>
+    <entry key="hyphenate-limit-before" value="1"/>
+    <entry key="hyphenate-limit-chars" value="4"/>
+    <entry key="hyphenate-limit-lines" value="4"/>
+    <entry key="hyphenate-limit-zone" value="4"/>
+    <entry key="hyphens" value="7"/>
+    <entry key="image-region" value="2"/>
+    <entry key="ime-mode" value="4"/>
+    <entry key="input-format" value="8"/>
+    <entry key="input-required" value="8"/>
+    <entry key="interpolation-mode" value="4"/>
+    <entry key="layout-flow" value="4"/>
+    <entry key="layout-grid" value="4"/>
+    <entry key="layout-grid-char" value="4"/>
+    <entry key="layout-grid-line" value="4"/>
+    <entry key="layout-grid-mode" value="4"/>
+    <entry key="layout-grid-type" value="4"/>
+    <entry key="line-box-contain" value="1"/>
+    <entry key="line-break" value="5"/>
+    <entry key="line-clamp" value="1"/>
+    <entry key="link" value="8"/>
+    <entry key="link-source" value="8"/>
+    <entry key="locale" value="1"/>
+    <entry key="margin-after-collapse" value="1"/>
+    <entry key="margin-before-collapse" value="1"/>
+    <entry key="marquee-dir" value="8"/>
+    <entry key="marquee-direction" value="1"/>
+    <entry key="marquee-increment" value="1"/>
+    <entry key="marquee-loop" value="8"/>
+    <entry key="marquee-repetition" value="1"/>
+    <entry key="marquee-speed" value="8"/>
+    <entry key="marquee-style" value="9"/>
+    <entry key="mask-attachment" value="1"/>
+    <entry key="mask-box-image" value="1"/>
+    <entry key="mask-box-image-outset" value="1"/>
+    <entry key="mask-box-image-repeat" value="1"/>
+    <entry key="mask-box-image-slice" value="1"/>
+    <entry key="mask-box-image-source" value="1"/>
+    <entry key="mask-box-image-width" value="1"/>
+    <entry key="mask-clip" value="1"/>
+    <entry key="mask-composite" value="1"/>
+    <entry key="mask-image" value="1"/>
+    <entry key="mask-origin" value="1"/>
+    <entry key="mask-position" value="1"/>
+    <entry key="mask-repeat" value="1"/>
+    <entry key="mask-size" value="1"/>
+    <entry key="nbsp-mode" value="1"/>
+    <entry key="object-fit" value="8"/>
+    <entry key="object-position" value="8"/>
+    <entry key="orient" value="2"/>
+    <entry key="outline-radius-bottomleft" value="2"/>
+    <entry key="outline-radius-bottomright" value="2"/>
+    <entry key="outline-radius-topleft" value="2"/>
+    <entry key="outline-radius-topright" value="2"/>
+    <entry key="overflow-style" value="4"/>
+    <entry key="perspective" value="7"/>
+    <entry key="perspective-origin" value="7"/>
+    <entry key="perspective-origin-x" value="4"/>
+    <entry key="perspective-origin-y" value="4"/>
+    <entry key="rtl-ordering" value="1"/>
+    <entry key="scroll-boundary" value="4"/>
+    <entry key="scroll-boundary-bottom" value="4"/>
+    <entry key="scroll-boundary-left" value="4"/>
+    <entry key="scroll-boundary-right" value="4"/>
+    <entry key="scroll-boundary-top" value="4"/>
+    <entry key="scroll-chaining" value="4"/>
+    <entry key="scroll-rails" value="4"/>
+    <entry key="scroll-snap-points-x" value="4"/>
+    <entry key="scroll-snap-points-y" value="4"/>
+    <entry key="scroll-snap-type" value="4"/>
+    <entry key="scroll-snap-x" value="4"/>
+    <entry key="scroll-snap-y" value="4"/>
+    <entry key="scrollbar-arrow-color" value="4"/>
+    <entry key="scrollbar-base-color" value="4"/>
+    <entry key="scrollbar-darkshadow-color" value="4"/>
+    <entry key="scrollbar-face-color" value="4"/>
+    <entry key="scrollbar-highlight-color" value="4"/>
+    <entry key="scrollbar-shadow-color" value="4"/>
+    <entry key="scrollbar-track-color" value="4"/>
+    <entry key="stack-sizing" value="2"/>
+    <entry key="svg-shadow" value="1"/>
+    <entry key="tab-size" value="10"/>
+    <entry key="table-baseline" value="8"/>
+    <entry key="text-align-last" value="4"/>
+    <entry key="text-autospace" value="4"/>
+    <entry key="text-blink" value="2"/>
+    <entry key="text-combine" value="1"/>
+    <entry key="text-decoration-color" value="2"/>
+    <entry key="text-decoration-line" value="2"/>
+    <entry key="text-decoration-style" value="2"/>
+    <entry key="text-decorations-in-effect" value="1"/>
+    <entry key="text-emphasis-color" value="1"/>
+    <entry key="text-emphasis-position" value="1"/>
+    <entry key="text-emphasis-style" value="1"/>
+    <entry key="text-fill-color" value="1"/>
+    <entry key="text-justify" value="4"/>
+    <entry key="text-kashida-space" value="4"/>
+    <entry key="text-orientation" value="1"/>
+    <entry key="text-overflow" value="4"/>
+    <entry key="text-security" value="1"/>
+    <entry key="text-size-adjust" value="6"/>
+    <entry key="text-stroke-color" value="1"/>
+    <entry key="text-stroke-width" value="1"/>
+    <entry key="text-underline-position" value="4"/>
+    <entry key="touch-action" value="4"/>
+    <entry key="transform" value="15"/>
+    <entry key="transform-origin" value="15"/>
+    <entry key="transform-origin-x" value="4"/>
+    <entry key="transform-origin-y" value="4"/>
+    <entry key="transform-origin-z" value="4"/>
+    <entry key="transform-style" value="7"/>
+    <entry key="transition" value="15"/>
+    <entry key="transition-delay" value="15"/>
+    <entry key="transition-duration" value="15"/>
+    <entry key="transition-property" value="15"/>
+    <entry key="transition-timing-function" value="15"/>
+    <entry key="user-drag" value="1"/>
+    <entry key="user-focus" value="2"/>
+    <entry key="user-input" value="2"/>
+    <entry key="user-modify" value="3"/>
+    <entry key="user-select" value="7"/>
+    <entry key="window-shadow" value="2"/>
+    <entry key="word-break" value="4"/>
+    <entry key="word-wrap" value="4"/>
+    <entry key="wrap-flow" value="4"/>
+    <entry key="wrap-margin" value="4"/>
+    <entry key="wrap-through" value="4"/>
+    <entry key="writing-mode" value="5"/>
+  </prefixes>
+</DefaultEmmetOptions>
\ No newline at end of file
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
index 6f4e29d58187..5d3ab8730412 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
@@ -15,7 +15,7 @@
  */
 package com.intellij.codeInsight.template.emmet;
 
-import com.intellij.application.options.editor.WebEditorOptions;
+import com.intellij.application.options.emmet.EmmetOptions;
 import com.intellij.codeInsight.CodeInsightBundle;
 import com.intellij.codeInsight.template.*;
 import com.intellij.codeInsight.template.emmet.filters.SingleLineEmmetFilter;
@@ -276,8 +276,8 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
   }
 
   public boolean isApplicable(PsiFile file, int offset, boolean wrapping) {
-    WebEditorOptions webEditorOptions = WebEditorOptions.getInstance();
-    if (!webEditorOptions.isZenCodingEnabled()) {
+    EmmetOptions emmetOptions = EmmetOptions.getInstance();
+    if (!emmetOptions.isEmmetEnabled()) {
       return false;
     }
     if (file == null) {
@@ -320,7 +320,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
   }
 
   public char getShortcut() {
-    return (char)WebEditorOptions.getInstance().getZenCodingExpandShortcut();
+    return (char)EmmetOptions.getInstance().getEmmetExpandShortcut();
   }
 
   public String computeTemplateKey(@NotNull CustomTemplateCallback callback) {
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/filters/BemEmmetFilter.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/filters/BemEmmetFilter.java
index f226864dd2c1..69b1adf67d8f 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/filters/BemEmmetFilter.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/filters/BemEmmetFilter.java
@@ -20,6 +20,7 @@ import com.google.common.base.Joiner;
 import com.google.common.base.Predicate;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableSet;
+import com.intellij.application.options.emmet.EmmetOptions;
 import com.intellij.codeInsight.template.emmet.nodes.GenerationNode;
 import com.intellij.lang.xml.XMLLanguage;
 import com.intellij.openapi.util.Key;
@@ -94,7 +95,7 @@ public class BemEmmetFilter extends ZenCodingFilter {
 
   @Override
   public boolean isAppliedByDefault(@NotNull PsiElement context) {
-    return false; //todo: add setting for enabling this filter by default
+    return EmmetOptions.getInstance().isBemFilterEnabledByDefault();
   }
 
   @Override
diff --git a/xml/impl/src/com/intellij/xml/util/ColorIconCache.java b/xml/impl/src/com/intellij/xml/util/ColorIconCache.java
index 15b31716e5ca..c0f01ad354eb 100644
--- a/xml/impl/src/com/intellij/xml/util/ColorIconCache.java
+++ b/xml/impl/src/com/intellij/xml/util/ColorIconCache.java
@@ -17,7 +17,6 @@ package com.intellij.xml.util;
 
 import com.intellij.util.containers.HashMap;
 import com.intellij.util.containers.SoftFactoryMap;
-import com.intellij.util.containers.WeakFactoryMap;
 import com.intellij.util.ui.EmptyIcon;
 import org.jetbrains.annotations.NotNull;
 
@@ -44,7 +43,6 @@ public class ColorIconCache {
     return INSTANCE;
   }
 
-  @SuppressWarnings({"MethodMayBeStatic"})
   public Icon getIcon(@NotNull final Color color, final int size) {
     Icon icon = ourCache.get(color).get(size);
     if (icon == null) {

From 10997d45226c1c2ab8575304df326c628b1d08c7 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Fri, 22 Feb 2013 15:52:56 +0100
Subject: [PATCH 052/354] IDEA-97594 fix linen texture for darcula

---
 .../icons/src/frame_background@2x_dark.png    | Bin 56781 -> 143118 bytes
 platform/icons/src/frame_background_dark.png  | Bin 56781 -> 66239 bytes
 .../fileEditor/impl/EditorsSplitters.java     |   5 +++--
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/platform/icons/src/frame_background@2x_dark.png b/platform/icons/src/frame_background@2x_dark.png
index 11af1396a9e9141f6191c6a01af2162ca5b5594a..6f5f605a1596ea047baed63931299bfab7089cfe 100644
GIT binary patch
literal 143118
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%0DSxeyQoy!Z9OO)}qzM>x
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
ToGlK3d>v_V1+iKYqmcgx{s6`-

literal 56781
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%0DN0f6uo=dlrLziVv
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
W5jGAOnd_hc0000<MNUMnLSTYym4>qb

diff --git a/platform/icons/src/frame_background_dark.png b/platform/icons/src/frame_background_dark.png
index 11af1396a9e9141f6191c6a01af2162ca5b5594a..71b25f083ca62f18838048b0a42c45e64749f964 100644
GIT binary patch
literal 66239
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
ViHm(W$5j9T002ovPDHLkV1n=j3z7f;

literal 56781
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%0DN0f6uo=dlrLziVv
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
W5jGAOnd_hc0000<MNUMnLSTYym4>qb

diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
index f33b29e377d1..cb82d467761b 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
@@ -38,6 +38,7 @@ import com.intellij.openapi.wm.ex.WindowManagerEx;
 import com.intellij.openapi.wm.impl.FrameTitleBuilder;
 import com.intellij.openapi.wm.impl.IdeFrameImpl;
 import com.intellij.ui.Gray;
+import com.intellij.ui.JBColor;
 import com.intellij.ui.awt.RelativePoint;
 import com.intellij.ui.components.JBPanel;
 import com.intellij.ui.docking.DockManager;
@@ -159,11 +160,11 @@ public class EditorsSplitters extends JBPanel {
     
     if (showEmptyText()) {
       UIUtil.applyRenderingHints(g);
-      g.setColor(UIUtil.isUnderDarcula() ? Gray._200 : Gray._100);
+      g.setColor(new JBColor(Gray._100, Gray._160));
       g.setFont(UIUtil.getLabelFont().deriveFont(UIUtil.isUnderDarcula() ? 24f : 18f));
 
       final UIUtil.TextPainter painter = new UIUtil.TextPainter().withShadow(true).withLineSpacing(1.4f);
-      painter.appendLine("No files are open").underlined(UIUtil.isUnderDarcula()? Gray._200 : Gray._150);
+      painter.appendLine("No files are open").underlined(new JBColor(Gray._150, Gray._100));
 
       if (!isProjectViewVisible()) {
         painter.appendLine("Open Project View with " + KeymapUtil.getShortcutText(new KeyboardShortcut(

From 0360850aa97749ccceb36ab9b315b1dce8482449 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 14:27:32 +0100
Subject: [PATCH 053/354] bomb prolongation

---
 .../ide/fileStructure/JavaFileStructureFilteringTest.java   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/java/java-tests/testSrc/com/intellij/ide/fileStructure/JavaFileStructureFilteringTest.java b/java/java-tests/testSrc/com/intellij/ide/fileStructure/JavaFileStructureFilteringTest.java
index e2632105a56c..abbb1522855d 100644
--- a/java/java-tests/testSrc/com/intellij/ide/fileStructure/JavaFileStructureFilteringTest.java
+++ b/java/java-tests/testSrc/com/intellij/ide/fileStructure/JavaFileStructureFilteringTest.java
@@ -38,10 +38,10 @@ public class JavaFileStructureFilteringTest extends JavaFileStructureTestCase {
   public void testSelectLeafFirst3()  throws Exception {checkTree("clear");}
   public void testSelectLeafFirst4()  throws Exception {checkTree("clear");}
 
-  @Bombed(user = "peter", month = Calendar.MARCH, day = 1)
+  @Bombed(user = "peter", month = Calendar.MAY, day = 10)
   public void testMatcher1()          throws Exception {checkTree("ico");}
-  @Bombed(user = "peter", month = Calendar.MARCH, day = 1)
+  @Bombed(user = "peter", month = Calendar.MAY, day = 10)
   public void testMatcher2()          throws Exception {checkTree("ico");}
-  @Bombed(user = "peter", month = Calendar.MARCH, day = 1)
+  @Bombed(user = "peter", month = Calendar.MAY, day = 10)
   public void testAnonymousMatcher2() throws Exception {checkTree("ico");}
 }

From e16b5e154bf54c9ee929e4f805f316c058bdafe9 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 15:22:56 +0100
Subject: [PATCH 054/354] [yann] make
 com.intellij.psi.search.GlobalSearchScope.moduleTestsWithDependentsScope
 return what it says

---
 .../core-api/src/com/intellij/psi/search/GlobalSearchScope.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/core-api/src/com/intellij/psi/search/GlobalSearchScope.java b/platform/core-api/src/com/intellij/psi/search/GlobalSearchScope.java
index 35026e9d64eb..6670be3590e2 100644
--- a/platform/core-api/src/com/intellij/psi/search/GlobalSearchScope.java
+++ b/platform/core-api/src/com/intellij/psi/search/GlobalSearchScope.java
@@ -243,7 +243,7 @@ public abstract class GlobalSearchScope extends SearchScope implements ProjectAw
 
   @NotNull
   public static GlobalSearchScope moduleTestsWithDependentsScope(@NotNull Module module) {
-    return module.getModuleWithDependentsScope();
+    return module.getModuleTestsWithDependentsScope();
   }
 
   @NotNull

From f2149065156f98ab251bc276a6d1778318966967 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 15:38:29 +0100
Subject: [PATCH 055/354] don't update parameter info for invalid target method
 (IDEA-101557)

---
 .../hint/api/impls/MethodParameterInfoHandler.java        | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java b/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java
index 8008c75ab5b6..73ac96b7a5d3 100644
--- a/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java
+++ b/java/java-impl/src/com/intellij/codeInsight/hint/api/impls/MethodParameterInfoHandler.java
@@ -431,7 +431,13 @@ public class MethodParameterInfoHandler implements ParameterInfoHandlerWithTabAc
   public void updateUI(final Object p, final ParameterInfoUIContext context) {
     if (p instanceof CandidateInfo) {
       CandidateInfo info = (CandidateInfo)p;
-      updateMethodPresentation((PsiMethod)info.getElement(), getCandidateInfoSubstitutor(info), context);
+      PsiMethod method = (PsiMethod)info.getElement();
+      if (!method.isValid()) {
+        context.setUIComponentEnabled(false);
+        return;
+      }
+
+      updateMethodPresentation(method, getCandidateInfoSubstitutor(info), context);
     }
     else {
       updateMethodPresentation((PsiMethod)p, null, context);

From 33dfda2803f4403116b08e710069c8b85b325299 Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Fri, 22 Feb 2013 19:16:37 +0400
Subject: [PATCH 056/354] WEB-6730 Emmet(css): Incorrect replacement in
 non-integer values with zero after the point

---
 .../codeInsight/template/emmet/EmmetLexer.java       |  5 +++--
 .../codeInsight/template/emmet/ZenCodingUtil.java    | 12 ++----------
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetLexer.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetLexer.java
index 66aed8db6a72..b44963cabf19 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetLexer.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetLexer.java
@@ -16,6 +16,7 @@
 package com.intellij.codeInsight.template.emmet;
 
 import com.intellij.codeInsight.template.emmet.tokens.*;
+import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -89,8 +90,8 @@ public class EmmetLexer {
 
         if (builder.length() > 0) {
           final String tokenText = builder.toString();
-          final int n = ZenCodingUtil.parseNonNegativeInt(tokenText);
-          if (n >= 0) {
+          final int n = StringUtil.parseInt(tokenText, -1);
+          if (!StringUtil.startsWithChar(tokenText, '0') && n >= 0) {
             result.add(new NumberToken(n));
           }
           else {
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingUtil.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingUtil.java
index 9b81e472680e..cb45efbee049 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingUtil.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingUtil.java
@@ -20,6 +20,7 @@ import com.intellij.codeInsight.template.emmet.filters.ZenCodingFilter;
 import com.intellij.codeInsight.template.emmet.generators.ZenCodingGenerator;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.fileTypes.StdFileTypes;
+import com.intellij.openapi.util.text.StringUtil;
 import org.apache.xerces.util.XML11Char;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -67,7 +68,7 @@ public class ZenCodingUtil {
               base.append(s.charAt(i));
               i++;
             }
-            int baseInt = parseNonNegativeInt(base.toString()) - 1;
+            int baseInt = StringUtil.parseInt(base.toString(), 0) - 1;
             baseInt = baseInt >= 0 ? baseInt : 0;
             if(baseInt >= 0) {
               int byInt = decrement
@@ -104,15 +105,6 @@ public class ZenCodingUtil {
     return s.replace("\"", "&quot;");
   }
 
-  public static int parseNonNegativeInt(@NotNull String s) {
-    try {
-      return Integer.parseInt(s);
-    }
-    catch (Throwable ignored) {
-    }
-    return -1;
-  }
-
   public static boolean isXML11ValidQName(String str) {
     final int colon = str.indexOf(':');
     if (colon == 0 || colon == str.length() - 1) {

From 6d90bd44938ec1577042403f1cfa043b2fc42562 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Fri, 22 Feb 2013 16:37:45 +0100
Subject: [PATCH 057/354] IDEABKL-2596 breakpoint gutter icon misaligned, when
 sharing gutter with bookmark

---
 .../debugger/ui/breakpoints/BreakpointWithHighlighter.java | 7 ++++++-
 .../xdebugger/impl/breakpoints/XBreakpointBase.java        | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
index a285463aeea4..0cf455de5068 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -616,6 +616,11 @@ public abstract class BreakpointWithHighlighter extends Breakpoint {
       return myDescription;
     }
 
+    @Override
+    public Alignment getAlignment() {
+      return Alignment.RIGHT;
+    }
+
     @Override
     public AnAction getClickAction() {
       return new AnAction() {
diff --git a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointBase.java b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointBase.java
index 16eb0e6ddbd4..aff7d2504594 100644
--- a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointBase.java
+++ b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointBase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -376,6 +376,11 @@ public class XBreakpointBase<Self extends XBreakpoint<P>, P extends XBreakpointP
       return new ToggleBreakpointGutterIconAction(XBreakpointBase.this);
     }
 
+    @Override
+    public Alignment getAlignment() {
+      return Alignment.RIGHT;
+    }
+
     @Nullable
     public ActionGroup getPopupMenuActions() {
       DefaultActionGroup group = new DefaultActionGroup();

From 7e72c0c5052f201c120138a26239b87f8d9bf772 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 16:42:02 +0100
Subject: [PATCH 058/354] javafx: simple optimize imports (IDEA-100174)

---
 .../impl/source/codeStyle/ImportHelper.java   | 135 +++++++++--------
 .../fxml/JavaFXOptimizeImportsTest.java       |  50 ++++++
 .../src/META-INF/common-javaFX-plugin.xml     |   1 +
 .../codeInsight/JavaFxImportsOptimizer.java   | 142 ++++++++++++++++++
 .../optimizeImports/collapseOnDemand.fxml     |  15 ++
 .../collapseOnDemand_after.fxml               |  10 ++
 .../optimizeImports/removeUnused.fxml         |  13 ++
 .../optimizeImports/removeUnused_after.fxml   |  11 ++
 8 files changed, 317 insertions(+), 60 deletions(-)
 create mode 100644 plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXOptimizeImportsTest.java
 create mode 100644 plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java
 create mode 100644 plugins/javaFX/testData/optimizeImports/collapseOnDemand.fxml
 create mode 100644 plugins/javaFX/testData/optimizeImports/collapseOnDemand_after.fxml
 create mode 100644 plugins/javaFX/testData/optimizeImports/removeUnused.fxml
 create mode 100644 plugins/javaFX/testData/optimizeImports/removeUnused_after.fxml

diff --git a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java
index ae1e9773bc8c..15716567cab7 100644
--- a/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java
+++ b/java/java-impl/src/com/intellij/psi/impl/source/codeStyle/ImportHelper.java
@@ -78,63 +78,10 @@ public class ImportHelper{
       }
     });
 
-    int[] entryForName = ArrayUtil.newIntArray(names.size());
-    PackageEntry[] entries = mySettings.IMPORT_LAYOUT_TABLE.getEntries();
-    for(int i = 0; i < names.size(); i++){
-      Pair<String, Boolean> pair = names.get(i);
-      String packageName = pair.getFirst();
-      Boolean isStatic = pair.getSecond();
-      entryForName[i] = findEntryIndex(packageName, isStatic, entries);
-    }
-
-    List<Pair<String, Boolean>> resultList = new ArrayList<Pair<String, Boolean>>(names.size());
-    for(int i = 0; i < entries.length; i++){
-      for(int j = 0; j < names.size(); j++){
-        if (entryForName[j] == i){
-          resultList.add(names.get(j));
-          names.set(j, null);
-        }
-      }
-    }
-    for (Pair<String, Boolean> name : names) {
-      if (name != null) resultList.add(name);
-    }
-
-    TObjectIntHashMap<String> packageToCountMap = new TObjectIntHashMap<String>();
-    TObjectIntHashMap<String> classToCountMap = new TObjectIntHashMap<String>();
-    for (Pair<String, Boolean> pair : resultList) {
-      String name = pair.getFirst();
-      Boolean isStatic = pair.getSecond();
-      String packageOrClassName = getPackageOrClassName(name);
-      if (packageOrClassName.length() == 0) continue;
-      if (isStatic) {
-        int count = classToCountMap.get(packageOrClassName);
-        classToCountMap.put(packageOrClassName, count + 1);
-      }
-      else {
-        int count = packageToCountMap.get(packageOrClassName);
-        packageToCountMap.put(packageOrClassName, count + 1);
-      }
-    }
+    List<Pair<String, Boolean>> resultList = sortItemsAccordingToSettings(names, mySettings);
 
     final Set<String> classesOrPackagesToImportOnDemand = new THashSet<String>();
-    class MyVisitorProcedure implements TObjectIntProcedure<String> {
-      private final boolean myIsVisitingPackages;
-
-      MyVisitorProcedure(boolean isVisitingPackages) {
-        myIsVisitingPackages = isVisitingPackages;
-      }
-
-      @Override
-      public boolean execute(final String packageOrClassName, final int count) {
-        if (isToUseImportOnDemand(packageOrClassName, count, !myIsVisitingPackages)){
-          classesOrPackagesToImportOnDemand.add(packageOrClassName);
-        }
-        return true;
-      }
-    }
-    classToCountMap.forEachEntry(new MyVisitorProcedure(false));
-    packageToCountMap.forEachEntry(new MyVisitorProcedure(true));
+    collectOnDemandImports(resultList, classesOrPackagesToImportOnDemand, ImportHelper.this.mySettings);
 
     Set<String> classesToUseSingle = findSingleImports(file, resultList, classesOrPackagesToImportOnDemand);
     Set<String> toReimport = new THashSet<String>();
@@ -176,6 +123,71 @@ public class ImportHelper{
     }
   }
 
+  public static void collectOnDemandImports(List<Pair<String, Boolean>> resultList,
+                                            final Set<String> classesOrPackagesToImportOnDemand, 
+                                            final CodeStyleSettings settings) {
+    TObjectIntHashMap<String> packageToCountMap = new TObjectIntHashMap<String>();
+    TObjectIntHashMap<String> classToCountMap = new TObjectIntHashMap<String>();
+    for (Pair<String, Boolean> pair : resultList) {
+      String name = pair.getFirst();
+      Boolean isStatic = pair.getSecond();
+      String packageOrClassName = getPackageOrClassName(name);
+      if (packageOrClassName.length() == 0) continue;
+      if (isStatic) {
+        int count = classToCountMap.get(packageOrClassName);
+        classToCountMap.put(packageOrClassName, count + 1);
+      }
+      else {
+        int count = packageToCountMap.get(packageOrClassName);
+        packageToCountMap.put(packageOrClassName, count + 1);
+      }
+    }
+
+
+    class MyVisitorProcedure implements TObjectIntProcedure<String> {
+      private final boolean myIsVisitingPackages;
+
+      MyVisitorProcedure(boolean isVisitingPackages) {
+        myIsVisitingPackages = isVisitingPackages;
+      }
+
+      @Override
+      public boolean execute(final String packageOrClassName, final int count) {
+        if (isToUseImportOnDemand(packageOrClassName, count, !myIsVisitingPackages, settings)){
+          classesOrPackagesToImportOnDemand.add(packageOrClassName);
+        }
+        return true;
+      }
+    }
+    classToCountMap.forEachEntry(new MyVisitorProcedure(false));
+    packageToCountMap.forEachEntry(new MyVisitorProcedure(true));
+  }
+
+  public static List<Pair<String, Boolean>> sortItemsAccordingToSettings(List<Pair<String, Boolean>> names, final CodeStyleSettings settings) {
+    int[] entryForName = ArrayUtil.newIntArray(names.size());
+    PackageEntry[] entries = settings.IMPORT_LAYOUT_TABLE.getEntries();
+    for(int i = 0; i < names.size(); i++){
+      Pair<String, Boolean> pair = names.get(i);
+      String packageName = pair.getFirst();
+      Boolean isStatic = pair.getSecond();
+      entryForName[i] = findEntryIndex(packageName, isStatic, entries);
+    }
+
+    List<Pair<String, Boolean>> resultList = new ArrayList<Pair<String, Boolean>>(names.size());
+    for(int i = 0; i < entries.length; i++){
+      for(int j = 0; j < names.size(); j++){
+        if (entryForName[j] == i){
+          resultList.add(names.get(j));
+          names.set(j, null);
+        }
+      }
+    }
+    for (Pair<String, Boolean> name : names) {
+      if (name != null) resultList.add(name);
+    }
+    return resultList;
+  }
+
   @NotNull
   private static Set<String> findSingleImports(@NotNull final PsiJavaFile file,
                                                @NotNull List<Pair<String,Boolean>> names,
@@ -620,13 +632,16 @@ public class ImportHelper{
     return maxSpace;
   }
 
-  private boolean isToUseImportOnDemand(@NotNull String packageName, int classCount, boolean isStaticImportNeeded){
-    if (!mySettings.USE_SINGLE_CLASS_IMPORTS) return true;
-    int limitCount = isStaticImportNeeded ? mySettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND :
-                     mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND;
+  private static boolean isToUseImportOnDemand(@NotNull String packageName,
+                                               int classCount,
+                                               boolean isStaticImportNeeded,
+                                               final CodeStyleSettings settings){
+    if (!settings.USE_SINGLE_CLASS_IMPORTS) return true;
+    int limitCount = isStaticImportNeeded ? settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND :
+                     settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND;
     if (classCount >= limitCount) return true;
     if (packageName.length() == 0) return false;
-    PackageEntryTable table = mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND;
+    PackageEntryTable table = settings.PACKAGES_TO_USE_IMPORT_ON_DEMAND;
     return table != null && table.contains(packageName);
   }
 
diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXOptimizeImportsTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXOptimizeImportsTest.java
new file mode 100644
index 000000000000..b3726abc3a14
--- /dev/null
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXOptimizeImportsTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml;
+
+import com.intellij.codeInsight.actions.OptimizeImportsProcessor;
+import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
+import com.intellij.openapi.application.PluginPathManager;
+import com.intellij.testFramework.PsiTestUtil;
+import org.jetbrains.annotations.NotNull;
+
+public class JavaFXOptimizeImportsTest extends DaemonAnalyzerTestCase {
+  @Override
+  protected void setUpModule() {
+    super.setUpModule();
+    PsiTestUtil.addLibrary(getModule(), "javafx", PluginPathManager.getPluginHomePath("javaFX") + "/testData", "jfxrt.jar");
+  }
+
+  public void testCollapseOnDemand() throws Exception {
+    doTest();
+  }
+
+  public void testRemoveUnused() throws Exception {
+    doTest();
+  }
+
+  private void doTest() throws Exception {
+    configureByFile(getTestName(true) + ".fxml");
+    new OptimizeImportsProcessor(getProject(), getFile()).run();
+    checkResultByFile(getTestName(true) + "_after.fxml");
+  }
+
+  @NotNull
+  @Override
+  protected String getTestDataPath() {
+    return PluginPathManager.getPluginHomePath("javaFX") + "/testData/optimizeImports/";
+  }
+}
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index 9c750c058946..c0ba7df0fc0b 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -24,6 +24,7 @@
       <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxCollapseSubTagToAttributeIntention</className>
       <category>JavaFX</category>
     </intentionAction>
+    <lang.importOptimizer language="XML" implementationClass="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer" order="before XML"/>
   </extensions>
 
   <actions>
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java
new file mode 100644
index 000000000000..fcffd00395d0
--- /dev/null
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/JavaFxImportsOptimizer.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml.codeInsight;
+
+import com.intellij.injected.editor.VirtualFileWindow;
+import com.intellij.lang.ASTNode;
+import com.intellij.lang.ImportOptimizer;
+import com.intellij.openapi.fileTypes.StdFileTypes;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.util.EmptyRunnable;
+import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.*;
+import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
+import com.intellij.psi.impl.source.codeStyle.ImportHelper;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.xml.*;
+import com.intellij.util.containers.HashSet;
+import com.intellij.xml.XmlElementDescriptor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.javaFX.fxml.JavaFxFileTypeFactory;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxClassBackedElementDescriptor;
+
+import java.util.*;
+
+/**
+ * User: anna
+ * Date: 2/22/13
+ */
+public class JavaFxImportsOptimizer implements ImportOptimizer {
+  @Override
+  public boolean supports(PsiFile file) {
+    return JavaFxFileTypeFactory.isFxml(file);
+  }
+
+  @NotNull
+  @Override
+  public Runnable processFile(final PsiFile file) {
+    VirtualFile vFile = file.getVirtualFile();
+    if (vFile instanceof VirtualFileWindow) vFile = ((VirtualFileWindow)vFile).getDelegate();
+    final Project project = file.getProject();
+    if (vFile == null || !ProjectRootManager.getInstance(project).getFileIndex().isInSourceContent(vFile)) {
+      return EmptyRunnable.INSTANCE;
+    }
+    final List<Pair<String, Boolean>> names = new ArrayList<Pair<String, Boolean>>();
+    collectNamesToImport(names, (XmlFile)file);
+    Collections.sort(names, new Comparator<Pair<String, Boolean>>() {
+      @Override
+      public int compare(Pair<String, Boolean> o1, Pair<String, Boolean> o2) {
+        return StringUtil.compare(o1.first, o2.first, true);
+      }
+    });
+    final CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(project);
+    final List<Pair<String, Boolean>> sortedNames = ImportHelper.sortItemsAccordingToSettings(names, settings);
+    final HashSet<String> onDemand = new HashSet<String>();
+    ImportHelper.collectOnDemandImports(sortedNames, onDemand, settings);
+    final Set<String> importedOnDemand = new HashSet<String>();
+    final List<String> imports = new ArrayList<String>();
+    for (Pair<String, Boolean> pair : sortedNames) {
+      final String qName = pair.first;
+      final String packageName = StringUtil.getPackageName(qName);
+      if (importedOnDemand.contains(packageName)) {
+        continue;
+      }
+      if (onDemand.contains(packageName)) {
+        importedOnDemand.add(packageName);
+        imports.add("<?import " + packageName + ".*?>");
+      } else {
+        imports.add("<?import " + qName + "?>");
+      }
+    }
+    final PsiFileFactory factory = PsiFileFactory.getInstance(file.getProject());
+    
+    final XmlFile dummyFile = (XmlFile)factory.createFileFromText("_Dummy_.fxml", StdFileTypes.XML, StringUtil.join(imports, "\n"));
+    final XmlDocument document = dummyFile.getDocument();
+    final XmlProlog newImportList = document.getProlog();
+    if (newImportList == null) return EmptyRunnable.getInstance();
+    return new Runnable() {
+      @Override
+      public void run() {
+        final XmlDocument xmlDocument = ((XmlFile)file).getDocument();
+        final XmlProlog prolog = xmlDocument.getProlog();
+        if (prolog != null) {
+          final Collection<XmlProcessingInstruction> instructions = PsiTreeUtil.findChildrenOfType(prolog, XmlProcessingInstruction.class);
+          for (final XmlProcessingInstruction instruction : instructions) {
+            final ASTNode node = instruction.getNode();
+            final ASTNode nameNode = node.findChildByType(XmlTokenType.XML_NAME);
+            if (nameNode != null && nameNode.getText().equals("import")) {
+              instruction.delete();
+            }
+          }
+          prolog.add(newImportList);
+        } else {
+          document.addBefore(newImportList, document.getRootTag());
+        }
+      }
+    };
+  }
+  
+  private static void collectNamesToImport(@NotNull final Collection<Pair<String, Boolean>> names, XmlFile file) {
+    file.accept(new XmlRecursiveElementVisitor(){
+      @Override
+      public void visitXmlProlog(XmlProlog prolog) {}
+
+      @Override
+      public void visitXmlProcessingInstruction(XmlProcessingInstruction processingInstruction) {}
+
+      @Override
+      public void visitXmlAttribute(XmlAttribute attribute) {}
+
+      @Override
+      public void visitXmlTag(XmlTag tag) {
+        super.visitXmlTag(tag);
+        final XmlElementDescriptor descriptor = tag.getDescriptor();
+        if (descriptor instanceof JavaFxClassBackedElementDescriptor) {
+          final PsiElement declaration = descriptor.getDeclaration();
+          if (declaration instanceof PsiClass) {
+            names.add(Pair.create(((PsiClass)declaration).getQualifiedName(), false));
+          }
+        }
+      }
+
+      
+    });
+  } 
+}
diff --git a/plugins/javaFX/testData/optimizeImports/collapseOnDemand.fxml b/plugins/javaFX/testData/optimizeImports/collapseOnDemand.fxml
new file mode 100644
index 000000000000..3cff767de1bd
--- /dev/null
+++ b/plugins/javaFX/testData/optimizeImports/collapseOnDemand.fxml
@@ -0,0 +1,15 @@
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.control.PasswordField?>
+<?import javafx.scene.control.RadioButton?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.TableView?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button/>
+    <Label/>
+    <PasswordField/>
+    <RadioButton/>
+    <CheckBox/>
+    <TableView/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/optimizeImports/collapseOnDemand_after.fxml b/plugins/javaFX/testData/optimizeImports/collapseOnDemand_after.fxml
new file mode 100644
index 000000000000..4077faa98f05
--- /dev/null
+++ b/plugins/javaFX/testData/optimizeImports/collapseOnDemand_after.fxml
@@ -0,0 +1,10 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button/>
+    <Label/>
+    <PasswordField/>
+    <RadioButton/>
+    <CheckBox/>
+    <TableView/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/optimizeImports/removeUnused.fxml b/plugins/javaFX/testData/optimizeImports/removeUnused.fxml
new file mode 100644
index 000000000000..2fa5bb457add
--- /dev/null
+++ b/plugins/javaFX/testData/optimizeImports/removeUnused.fxml
@@ -0,0 +1,13 @@
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.control.PasswordField?>
+<?import javafx.scene.control.RadioButton?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.TableView?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button/>
+    <Label/>
+    <PasswordField/>
+    <RadioButton/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/optimizeImports/removeUnused_after.fxml b/plugins/javaFX/testData/optimizeImports/removeUnused_after.fxml
new file mode 100644
index 000000000000..a1527c070f9d
--- /dev/null
+++ b/plugins/javaFX/testData/optimizeImports/removeUnused_after.fxml
@@ -0,0 +1,11 @@
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.PasswordField?>
+<?import javafx.scene.control.RadioButton?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button/>
+    <Label/>
+    <PasswordField/>
+    <RadioButton/>
+</GridPane>
\ No newline at end of file

From f62d517244c63e0f1483bdc7ee2c6f7492eec110 Mon Sep 17 00:00:00 2001
From: Anton Makeev <Anton.Makeev@jetbrains.com>
Date: Fri, 22 Feb 2013 16:47:51 +0100
Subject: [PATCH 059/354] SMRunner: builder for testIgnored message +review
 CR_IC

---
 .../sm/ServiceMessageBuilder.java             | 44 ++++++++++++-------
 1 file changed, 28 insertions(+), 16 deletions(-)

diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/ServiceMessageBuilder.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/ServiceMessageBuilder.java
index f2a57b227aa7..0ee49eaa1804 100644
--- a/platform/smRunner/src/com/intellij/execution/testframework/sm/ServiceMessageBuilder.java
+++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/ServiceMessageBuilder.java
@@ -16,10 +16,12 @@
 package com.intellij.execution.testframework.sm;
 
 import jetbrains.buildServer.messages.serviceMessages.MapSerializerUtil;
+import jetbrains.buildServer.messages.serviceMessages.ServiceMessageTypes;
+import org.jetbrains.annotations.NotNull;
 
 /**
-* @author gregsh
-*/
+ * @author gregsh
+ */
 public class ServiceMessageBuilder {
   private final StringBuilder myText = new StringBuilder("##teamcity[");
 
@@ -41,25 +43,35 @@ public class ServiceMessageBuilder {
     return MapSerializerUtil.escapeStr(text, MapSerializerUtil.STD_ESCAPER);
   }
 
-  public static ServiceMessageBuilder testSuiteStarted(final String name) {
-    return new ServiceMessageBuilder("testSuiteStarted").addAttribute("name", name);
+  public static ServiceMessageBuilder testSuiteStarted(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_SUITE_STARTED).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testSuiteFinished(final String name) {
-    return new ServiceMessageBuilder("testSuiteFinished").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testSuiteFinished(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_SUITE_FINISHED).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testStarted(final String name) {
-    return new ServiceMessageBuilder("testStarted").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testStarted(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_STARTED).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testFinished(final String name) {
-    return new ServiceMessageBuilder("testFinished").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testFinished(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_FINISHED).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testStdOut(final String name) {
-    return new ServiceMessageBuilder("testStdOut").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testStdOut(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_STD_OUT).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testStdErr(final String name) {
-    return new ServiceMessageBuilder("testStdErr").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testStdErr(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_STD_ERR).addAttribute("name", name);
   }
-  public static ServiceMessageBuilder testFailed(final String name) {
-    return new ServiceMessageBuilder("testFailed").addAttribute("name", name);
+
+  public static ServiceMessageBuilder testFailed(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_FAILED).addAttribute("name", name);
+  }
+
+  public static ServiceMessageBuilder testIgnored(@NotNull String name) {
+    return new ServiceMessageBuilder(ServiceMessageTypes.TEST_IGNORED).addAttribute("name", name);
   }
 }

From ae652bdcbd2727c1984bed2ad93e604b3b220e67 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 17:04:37 +0100
Subject: [PATCH 060/354] less unwanted matches in testdata

---
 .../plugins/groovy/dsl/GroovyTransformationsTest.groovy         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/dsl/GroovyTransformationsTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/dsl/GroovyTransformationsTest.groovy
index 3b025a6ee095..5ab7131f3eb7 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/dsl/GroovyTransformationsTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/dsl/GroovyTransformationsTest.groovy
@@ -42,7 +42,7 @@ class GroovyTransformationsTest extends LightCodeInsightFixtureTestCase {
 
   public void testCategoryTransform() throws Throwable { doVariantsTest('name', 'getName', 'FileNameByRegexFinder', 'FileNameFinder', 'FilenameFilter', 'IFileNameFinder') }
 
-  public void testMixinTransform() throws Throwable { doVariantsTest('dive', 'findIndexValues', 'findIndexValues') }
+  public void testMixinTransform() throws Throwable { doPlainTest() }
 
   public void testBindableTransform() throws Throwable { doPlainTest() }
 

From 1e12d6d4fc354e26a2f61112af33887eb7d2f71a Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 17:06:21 +0100
Subject: [PATCH 061/354] apply start-matching case-insensitively whatever the
 completion matching option is

---
 .../normalSorting/EnumConstantStartMatching.java     | 12 ++++++++++++
 .../completion/NormalCompletionOrderingTest.groovy   | 12 ++++++++++--
 .../completion/impl/CamelHumpMatcher.java            |  6 ------
 3 files changed, 22 insertions(+), 8 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/completion/normalSorting/EnumConstantStartMatching.java

diff --git a/java/java-tests/testData/codeInsight/completion/normalSorting/EnumConstantStartMatching.java b/java/java-tests/testData/codeInsight/completion/normalSorting/EnumConstantStartMatching.java
new file mode 100644
index 000000000000..1521cfd0521f
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/completion/normalSorting/EnumConstantStartMatching.java
@@ -0,0 +1,12 @@
+public class Foo {
+  
+  Zoo foo() {
+    return r<caret>
+  }
+
+  void rMethod() {}
+}
+
+enum Zoo {
+  LEFT, RIGHT
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy
index d9fa374fbe7e..c1fc757f89e5 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionOrderingTest.groovy
@@ -98,11 +98,11 @@ public class NormalCompletionOrderingTest extends CompletionSortingTestCase {
   }
 
   public void testDispreferDeclared() throws Throwable {
-    checkPreferredItems(0, "aabbb", "aaa");
+    checkPreferredItems(0, "aabbb", "Aaaaaaa", "aaa");
   }
 
   public void testDispreferDeclaredOfExpectedType() throws Throwable {
-    checkPreferredItems(0, "aabbb", "aaa");
+    checkPreferredItems(0, "aabbb", "Aaaaaaa", "aaa");
   }
 
   public void testDispreferImpls() throws Throwable {
@@ -596,4 +596,12 @@ import java.lang.annotation.Target;
     assertPreferredItems 0, 'setText', 'setOurText'
   }
 
+  public void testEnumConstantStartMatching() {
+    checkPreferredItems(0, 'rMethod', 'Zoo.RIGHT')
+    myFixture.type('i\n;\nreturn r')
+    myFixture.completeBasic()
+    assertPreferredItems 0, 'Zoo.RIGHT', 'rMethod'
+
+  }
+
 }
diff --git a/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java b/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java
index 1901ca31e02e..e88506016808 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/completion/impl/CamelHumpMatcher.java
@@ -43,12 +43,6 @@ public class CamelHumpMatcher extends PrefixMatcher {
 
   @Override
   public boolean isStartMatch(LookupElement element) {
-    if (super.isStartMatch(element)) {
-      return true;
-    }
-    if (element.isCaseSensitive()) {
-      return false;
-    }
     return ContainerUtil.or(element.getAllLookupStrings(), new Condition<String>() {
       @Override
       public boolean value(String s) {

From c4c80d5fbfc85823881b8161c6b15e1c16fdb2fb Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 17:46:35 +0100
Subject: [PATCH 062/354] don't update parameter info component if it has been
 disposed (IDEA-101557)

---
 .../com/intellij/codeInsight/hint/ParameterInfoController.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoController.java b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoController.java
index a486736b6c4d..a16223f1fd49 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoController.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoController.java
@@ -274,7 +274,7 @@ public class ParameterInfoController {
 
     if (elementForUpdating != null) {
       myHandler.updateParameterInfo(elementForUpdating, context);
-      if (myHint.isVisible() && myEditor.getComponent().getRootPane() != null) {
+      if (!myDisposed && myHint.isVisible() && myEditor.getComponent().getRootPane() != null) {
         myComponent.update();
         Pair<Point,Short> pos = myProvider.getBestPointPosition(myHint, (PsiElement)elementForUpdating, offset, true, HintManager.UNDER);
         HintManagerImpl.adjustEditorHintPosition(myHint, myEditor, pos.getFirst(), pos.getSecond());

From d2649e626bdd233e89721b461e86d83b17eb549f Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 17:55:33 +0100
Subject: [PATCH 063/354] javafx: sort refs from bottom to top (IDEA-101687)

---
 .../moveClassesOrPackages/CommonMoveUtil.java | 25 ++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/CommonMoveUtil.java b/platform/lang-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/CommonMoveUtil.java
index 475c16c2f326..4a1591dbac98 100644
--- a/platform/lang-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/CommonMoveUtil.java
+++ b/platform/lang-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/CommonMoveUtil.java
@@ -1,6 +1,9 @@
 package com.intellij.refactoring.move.moveClassesOrPackages;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.ProperTextRange;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
 import com.intellij.refactoring.util.MoveRenameUsageInfo;
@@ -8,9 +11,7 @@ import com.intellij.refactoring.util.NonCodeUsageInfo;
 import com.intellij.usageView.UsageInfo;
 import com.intellij.util.IncorrectOperationException;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 public class CommonMoveUtil {
 
@@ -21,6 +22,24 @@ public class CommonMoveUtil {
 
   public static NonCodeUsageInfo[] retargetUsages(final UsageInfo[] usages, final Map<PsiElement, PsiElement> oldToNewElementsMapping)
     throws IncorrectOperationException {
+    Arrays.sort(usages, new Comparator<UsageInfo>() {
+      @Override
+      public int compare(UsageInfo o1, UsageInfo o2) {
+        final VirtualFile file1 = o1.getVirtualFile();
+        final VirtualFile file2 = o2.getVirtualFile();
+        if (Comparing.equal(file1, file2)) {
+          final ProperTextRange rangeInElement1 = o1.getRangeInElement();
+          final ProperTextRange rangeInElement2 = o2.getRangeInElement();
+          if (rangeInElement1 != null && rangeInElement2 != null) {
+            return rangeInElement2.getStartOffset() - rangeInElement1.getStartOffset();
+          }
+          return 0;
+        }
+        if (file1 == null) return -1;
+        if (file2 == null) return 1;
+        return Comparing.compare(file1.getPath(), file2.getPath());
+      }
+    });
     List<NonCodeUsageInfo> nonCodeUsages = new ArrayList<NonCodeUsageInfo>();
     for (UsageInfo usage : usages) {
       if (usage instanceof NonCodeUsageInfo) {

From 6309e7268e8a7e159218f5d7701a56f92da27839 Mon Sep 17 00:00:00 2001
From: Eugene Kudelevsky <Eugene.Kudelevsky@jetbrains.com>
Date: Fri, 22 Feb 2013 21:10:21 +0400
Subject: [PATCH 064/354] IDEA-98114 find/create new libs for the dependencies
 of external apklib artifact according to its own configuration, instead of
 searching them among referring module roots

---
 .../idea/maven/importing/MavenModuleImporter.java    | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleImporter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleImporter.java
index 2b834631b8cc..05c5d58551ae 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleImporter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenModuleImporter.java
@@ -15,18 +15,11 @@
  */
 package org.jetbrains.idea.maven.importing;
 
-import com.intellij.compiler.CompilerConfiguration;
-import com.intellij.compiler.CompilerConfigurationImpl;
-import com.intellij.openapi.compiler.options.ExcludeEntryDescription;
-import com.intellij.openapi.compiler.options.ExcludedEntriesConfiguration;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleType;
-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.roots.libraries.LibraryTable;
-import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
@@ -39,10 +32,7 @@ import org.jetbrains.idea.maven.model.MavenArtifact;
 import org.jetbrains.idea.maven.model.MavenConstants;
 import org.jetbrains.idea.maven.project.*;
 import org.jetbrains.idea.maven.utils.MavenUtil;
-import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile;
-import org.jetbrains.jps.model.java.impl.compiler.ProcessorConfigProfileImpl;
 
-import java.io.File;
 import java.util.List;
 import java.util.Map;
 
@@ -246,7 +236,7 @@ public class MavenModuleImporter {
   }
 
   @NotNull
-  private static DependencyScope selectScope(String mavenScope) {
+  public static DependencyScope selectScope(String mavenScope) {
     if (MavenConstants.SCOPE_RUNTIME.equals(mavenScope)) return DependencyScope.RUNTIME;
     if (MavenConstants.SCOPE_TEST.equals(mavenScope)) return DependencyScope.TEST;
     if (MavenConstants.SCOPE_PROVIDEED.equals(mavenScope)) return DependencyScope.PROVIDED;

From abaf56fd4960e12845f223e59804d86bb4abca71 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 18:33:09 +0100
Subject: [PATCH 065/354] equals method fixed

---
 .../plugins/javaFX/fxml/refs/JavaFxAnnotator.java | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxAnnotator.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxAnnotator.java
index 867c6d760df7..9da83e9eee7a 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxAnnotator.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxAnnotator.java
@@ -15,7 +15,6 @@
  */
 package org.jetbrains.plugins.javaFX.fxml.refs;
 
-import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.codeInsight.intention.AddAnnotationFix;
 import com.intellij.codeInsight.intentions.XmlChooseColorIntentionAction;
 import com.intellij.lang.annotation.Annotation;
@@ -32,12 +31,10 @@ import com.intellij.psi.presentation.java.SymbolPresentationUtil;
 import com.intellij.psi.util.InheritanceUtil;
 import com.intellij.psi.xml.XmlAttribute;
 import com.intellij.psi.xml.XmlAttributeValue;
-import com.intellij.psi.xml.XmlTag;
 import com.intellij.ui.ColorUtil;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.ui.ColorIcon;
 import com.intellij.xml.XmlAttributeDescriptor;
-import com.intellij.xml.XmlElementDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.javaFX.fxml.FxmlConstants;
 import org.jetbrains.plugins.javaFX.fxml.JavaFxCommonClassNames;
@@ -47,7 +44,6 @@ import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxPropertyAttributeDesc
 
 import javax.swing.*;
 import java.awt.*;
-import java.util.Collections;
 
 /**
  * User: anna
@@ -132,8 +128,15 @@ public class JavaFxAnnotator implements Annotator {
     }
 
     @Override
-    public boolean equals(Object obj) {
-      return myElement.equals(obj);
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      ColorIconRenderer renderer = (ColorIconRenderer)o;
+
+      if (myElement != null ? !myElement.equals(renderer.myElement) : renderer.myElement != null) return false;
+
+      return true;
     }
 
     @Override

From 913554f408efb52f77efc8b0017c1422ce2652c2 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 18:45:06 +0100
Subject: [PATCH 066/354] IDEA-101689 incorrect control-flow analisys

---
 .../dataFlow/ControlFlowAnalyzer.java         |  2 +-
 .../fixture/NotNullCatchParameter.java        | 21 +++++++++++++++++++
 .../DataFlowInspectionTest.java               |  1 +
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 java/java-tests/testData/inspection/dataFlow/fixture/NotNullCatchParameter.java

diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
index e3170217680f..1107a2e8f955 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
@@ -1218,7 +1218,7 @@ class ControlFlowAnalyzer extends JavaElementVisitor {
         ConditionalGotoInstruction cond = new ConditionalGotoInstruction(NOT_FOUND, false, null);
         addInstruction(cond);
         addInstruction(new EmptyStackInstruction());
-        addInstruction(new PushInstruction(myFactory.getTypeFactory().create(ref), null));
+        addInstruction(new PushInstruction(myFactory.getNotNullFactory().create(ref), null));
         addThrowCode(ref);
         cond.setOffset(myCurrentFlow.getInstructionCount());
       }
diff --git a/java/java-tests/testData/inspection/dataFlow/fixture/NotNullCatchParameter.java b/java/java-tests/testData/inspection/dataFlow/fixture/NotNullCatchParameter.java
new file mode 100644
index 000000000000..cb8849b090d7
--- /dev/null
+++ b/java/java-tests/testData/inspection/dataFlow/fixture/NotNullCatchParameter.java
@@ -0,0 +1,21 @@
+class MyException extends Exception {}
+
+class Foo {
+  public static void main(String[] args) {
+    try {
+      bar();
+    } catch (Exception e) {
+      if (e instanceof MyException) {
+        return;
+      }
+      if (<warning descr="Condition 'e instanceof RuntimeException' is always 'true'">e instanceof RuntimeException</warning>) {
+        return;
+      }
+      e.printStackTrace();
+    }
+  }
+
+  private static void bar() throws MyException {
+  }
+
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
index 56fa8115d95f..eb2ec6a3fd5a 100644
--- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
@@ -90,6 +90,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase {
   public void testReturningNullFromVoidMethod() throws Throwable { doTest(); }
 
   public void testCatchRuntimeException() throws Throwable { doTest(); }
+  public void testNotNullCatchParameter() { doTest(); }
 
   public void testAssertFailInCatch() throws Throwable {
     myFixture.addClass("package org.junit; public class Assert { public static void fail() {}}");

From c1bdf8c317232fe9b857f8e81a24f60daaf2491d Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 19:30:41 +0100
Subject: [PATCH 067/354] check annotation applicable special

---
 .../src/com/intellij/codeInsight/AnnotationUtil.java        | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java
index 0ca2c3709680..d67dec73361f 100644
--- a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java
+++ b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationUtil.java
@@ -293,9 +293,13 @@ public class AnnotationUtil {
   }
 
   public static boolean isAnnotatingApplicable(@NotNull PsiElement elt) {
+    return isAnnotatingApplicable(elt, NullableNotNullManager.getInstance(elt.getProject()).getDefaultNullable());
+  }
+
+  public static boolean isAnnotatingApplicable(@NotNull PsiElement elt, final String annotationFQN) {
     final Project project = elt.getProject();
     return PsiUtil.isLanguageLevel5OrHigher(elt) &&
-           JavaPsiFacade.getInstance(project).findClass(NullableNotNullManager.getInstance(project).getDefaultNullable(), elt.getResolveScope()) != null;
+           JavaPsiFacade.getInstance(project).findClass(annotationFQN, elt.getResolveScope()) != null;
   }
 
   public static boolean isJetbrainsAnnotation(@NonNls final String simpleName) {

From d171b0044b1600ad81ffb250fae3f28f0d262617 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 20:21:09 +0100
Subject: [PATCH 068/354] nullable/notnull defaults: suggest to change defaults
 when they are not applicable; do not insert inapplicable annotation
 (IDEA-99232)

---
 .../codeInspection/AnnotateMethodFix.java     |  2 +-
 .../AnnotateOverriddenMethodParameterFix.java |  4 +-
 .../nullable/ChangeNullableDefaultsFix.java   | 66 +++++++++++++++++++
 .../nullable/NullableStuffInspection.java     | 45 +++++++++++--
 4 files changed, 109 insertions(+), 8 deletions(-)
 create mode 100644 java/java-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java

diff --git a/java/java-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java b/java/java-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java
index 88cc269db319..6861ff990ac7 100644
--- a/java/java-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java
@@ -76,7 +76,7 @@ public class AnnotateMethodFix implements LocalQuickFix {
     if (annotateOverriddenMethods()) {
       PsiMethod[] methods = OverridingMethodsSearch.search(method, GlobalSearchScope.allScope(project), true).toArray(PsiMethod.EMPTY_ARRAY);
       for (PsiMethod psiMethod : methods) {
-        if (!AnnotationUtil.isAnnotated(psiMethod, myAnnotation, false, false) && psiMethod.getManager().isInProject(psiMethod)) {
+        if (AnnotationUtil.isAnnotatingApplicable(psiMethod, myAnnotation) && !AnnotationUtil.isAnnotated(psiMethod, myAnnotation, false, false) && psiMethod.getManager().isInProject(psiMethod)) {
           toAnnotate.add(psiMethod);
         }
       }
diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/AnnotateOverriddenMethodParameterFix.java b/java/java-impl/src/com/intellij/codeInspection/nullable/AnnotateOverriddenMethodParameterFix.java
index a8edce01d507..03a202db332e 100644
--- a/java/java-impl/src/com/intellij/codeInspection/nullable/AnnotateOverriddenMethodParameterFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/nullable/AnnotateOverriddenMethodParameterFix.java
@@ -81,7 +81,9 @@ public class AnnotateOverriddenMethodParameterFix implements LocalQuickFix {
     for (PsiParameter psiParam : toAnnotate) {
       try {
         assert psiParam != null : toAnnotate;
-        new AddAnnotationFix(myAnnotation, psiParam, myAnnosToRemove).invoke(project, null, psiParam.getContainingFile());
+        if (AnnotationUtil.isAnnotatingApplicable(psiParam, myAnnotation)) {
+          new AddAnnotationFix(myAnnotation, psiParam, myAnnosToRemove).invoke(project, null, psiParam.getContainingFile());
+        }
       }
       catch (IncorrectOperationException e) {
         LOG.error(e);
diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java b/java/java-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java
new file mode 100644
index 000000000000..53b439f0d2d5
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2000-2013 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.codeInspection.nullable;
+
+import com.intellij.codeInsight.NullableNotNullManager;
+import com.intellij.codeInspection.LocalQuickFix;
+import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiAnnotation;
+import org.jetbrains.annotations.NotNull;
+
+/**
+* User: anna
+* Date: 2/22/13
+*/
+class ChangeNullableDefaultsFix implements LocalQuickFix {
+  private final NullableNotNullManager myManager;
+  private final String myNotNullName;
+  private final String myNullableName;
+
+  public ChangeNullableDefaultsFix(PsiAnnotation notNull, PsiAnnotation nullable, NullableNotNullManager manager) {
+    myNotNullName = notNull != null ? notNull.getQualifiedName() : null;
+    myNullableName = nullable != null ? nullable.getQualifiedName() : null;
+    myManager = manager;
+  }
+
+  ChangeNullableDefaultsFix(String notNull, String nullable, NullableNotNullManager manager) {
+    myManager = manager;
+    myNotNullName = notNull;
+    myNullableName = nullable;
+  }
+
+  @NotNull
+  @Override
+  public String getName() {
+    return "Make \"" + (myNotNullName != null ? myNotNullName : myNullableName) + "\" default annotation";
+  }
+
+  @NotNull
+  @Override
+  public String getFamilyName() {
+    return getName();
+  }
+
+  @Override
+  public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
+    if (myNotNullName != null) {
+      myManager.setDefaultNotNull(myNotNullName);
+    } else {
+      myManager.setDefaultNullable(myNullableName);
+    }
+  }
+}
diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
index c2eb806257b7..eafc30013451 100644
--- a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
@@ -85,6 +85,14 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
           final String anno = annotated.isDeclaredNotNull ? manager.getDefaultNotNull() : manager.getDefaultNullable();
           final List<String> annoToRemove = annotated.isDeclaredNotNull ? manager.getNullables() : manager.getNotNulls();
 
+          if (!AnnotationUtil.isAnnotatingApplicable(field, anno)) {
+            final PsiAnnotation notNull = AnnotationUtil.findAnnotation(field, manager.getNotNulls());
+            final PsiAnnotation nullable = AnnotationUtil.findAnnotation(field, manager.getNullables());
+            holder.registerProblem(field.getNameIdentifier(), "Nullable/NotNull defaults are not accessible in current context",
+                                   new ChangeNullableDefaultsFix(notNull, nullable, manager));
+            return;
+          }
+
           String propName = JavaCodeStyleManager.getInstance(project).variableNameToPropertyName(field.getName(), VariableKind.FIELD);
           final boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
           final PsiMethod getter = PropertyUtil.findPropertyGetter(field.getContainingClass(), propName, isStatic, false);
@@ -289,9 +297,13 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
         reported_not_annotated_method_overrides_notnull = true;
         final String defaultNotNull = nullableManager.getDefaultNotNull();
         final String[] annotationsToRemove = ArrayUtil.toStringArray(nullableManager.getNullables());
+        final LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(method, defaultNotNull)
+                                  ? createAnnotateMethodFix(defaultNotNull, annotationsToRemove)
+                                  : createChangeDefaultNotNullFix(nullableManager, superMethod);
         holder.registerProblem(method.getNameIdentifier(),
                                InspectionsBundle.message("inspection.nullable.problems.method.overrides.NotNull"),
-                               ProblemHighlightType.GENERIC_ERROR_OR_WARNING, createAnnotateMethodFix(defaultNotNull, annotationsToRemove));
+                               ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                               fix);
       }
       if (REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE || REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL) {
         PsiParameter[] superParameters = superMethod.getParameterList().getParameters();
@@ -313,10 +325,13 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
             if (!AnnotationUtil.isAnnotated(parameter, nullableManager.getAllAnnotations(), false, false) &&
                 nullableManager.isNotNull(superParameter, false)) {
               reported_not_annotated_parameter_overrides_notnull[i] = true;
+              final LocalQuickFix fix = AnnotationUtil.isAnnotatingApplicable(parameter, nullableManager.getDefaultNotNull()) 
+                                        ? new AddNotNullAnnotationFix(parameter) 
+                                        : createChangeDefaultNotNullFix(nullableManager, superParameter);
               holder.registerProblem(parameter.getNameIdentifier(),
                                      InspectionsBundle.message("inspection.nullable.problems.parameter.overrides.NotNull"),
                                      ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                     new AddNotNullAnnotationFix(parameter));
+                                     fix);
             }
           }
         }
@@ -334,22 +349,34 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
       }
       if (hasAnnotatedParameter || annotated.isDeclaredNotNull) {
         PsiManager manager = method.getManager();
+        final String defaultNotNull = nullableManager.getDefaultNotNull();
+        final boolean superMethodApplicable = AnnotationUtil.isAnnotatingApplicable(method, defaultNotNull);
         PsiMethod[] overridings =
           OverridingMethodsSearch.search(method, GlobalSearchScope.allScope(manager.getProject()), true).toArray(PsiMethod.EMPTY_ARRAY);
         boolean methodQuickFixSuggested = false;
         for (PsiMethod overriding : overridings) {
           if (!manager.isInProject(overriding)) continue;
+          
+          final boolean applicable = AnnotationUtil.isAnnotatingApplicable(overriding, defaultNotNull);
           if (!methodQuickFixSuggested
               && annotated.isDeclaredNotNull
               && !nullableManager.isNotNull(overriding, false) 
               && (nullableManager.isNullable(overriding, false) || !nullableManager.isNullable(overriding, true))) {
             method.getNameIdentifier(); //load tree
-            PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, nullableManager.getNotNulls());
-            final String defaultNotNull = nullableManager.getDefaultNotNull();
+            PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, nullableManager.getNotNulls());            
             final String[] annotationsToRemove = ArrayUtil.toStringArray(nullableManager.getNullables());
+
+            final LocalQuickFix fix;
+            if (applicable) {
+              fix = new MyAnnotateMethodFix(defaultNotNull, annotationsToRemove);
+            }
+            else {
+              fix = superMethodApplicable ? null : createChangeDefaultNotNullFix(nullableManager, method);
+            }
+
             holder.registerProblem(annotation, InspectionsBundle.message("nullable.stuff.problems.overridden.methods.are.not.annotated"),
                                    ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                   new MyAnnotateMethodFix(defaultNotNull, annotationsToRemove));
+                                   fix);
             methodQuickFixSuggested = true;
           }
           if (hasAnnotatedParameter) {
@@ -363,7 +390,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
                 holder.registerProblem(annotation,
                                        InspectionsBundle.message("nullable.stuff.problems.overridden.method.parameters.are.not.annotated"),
                                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                       new AnnotateOverriddenMethodParameterFix(nullableManager.getDefaultNotNull(), nullableManager.getDefaultNullable()));
+                                       !applicable ? createChangeDefaultNotNullFix(nullableManager, parameters[i]) : new AnnotateOverriddenMethodParameterFix(defaultNotNull, nullableManager.getDefaultNullable()));
                 parameterQuickFixSuggested[i] = true;
               }
             }
@@ -373,6 +400,12 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
     }
   }
 
+  private static LocalQuickFix createChangeDefaultNotNullFix(NullableNotNullManager nullableManager, PsiModifierListOwner modifierListOwner) {
+    final PsiAnnotation annotation = AnnotationUtil.findAnnotation(modifierListOwner, nullableManager.getNotNulls());
+    LOG.assertTrue(annotation != null);
+    return new ChangeNullableDefaultsFix(annotation.getQualifiedName(), null, nullableManager);
+  }
+
   protected AnnotateMethodFix createAnnotateMethodFix(final String defaultNotNull, final String[] annotationsToRemove) {
     return new AnnotateMethodFix(defaultNotNull, annotationsToRemove);
   }

From de28ee70a65497c9273d91e119bdccf6e5fc57be Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 21:31:00 +0100
Subject: [PATCH 069/354] javafx: add reference from Main to corresponding
 layout

---
 .../javaFX/fxml/JavaFXHighlightingTest.java   | 16 +++-
 plugins/javaFX/javaFX.iml                     |  1 +
 .../src/META-INF/common-javaFX-plugin.xml     |  1 +
 .../javaFX/fxml/JavaFxCommonClassNames.java   |  1 +
 .../refs/JavaFxReferencesContributor.java     | 95 +++++++++++++++++++
 .../NavigationFromMainToFxml.java             | 21 ++++
 .../navigationFromMainToFxml.fxml             |  2 +
 7 files changed, 134 insertions(+), 3 deletions(-)
 create mode 100644 plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
 create mode 100644 plugins/javaFX/testData/highlighting/NavigationFromMainToFxml.java
 create mode 100644 plugins/javaFX/testData/highlighting/navigationFromMainToFxml.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
index 666f905be3a2..f66c68429f01 100644
--- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
@@ -20,9 +20,7 @@ import com.intellij.codeInsight.daemon.impl.analysis.XmlPathReferenceInspection;
 import com.intellij.codeInspection.LocalInspectionTool;
 import com.intellij.codeInspection.htmlInspections.RequiredAttributesInspection;
 import com.intellij.openapi.application.PluginPathManager;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiReference;
+import com.intellij.psi.*;
 import com.intellij.psi.search.ProjectScope;
 import com.intellij.testFramework.PsiTestUtil;
 import com.intellij.util.ArrayUtil;
@@ -144,6 +142,18 @@ public class JavaFXHighlightingTest extends DaemonAnalyzerTestCase {
     assertEquals(resultField, reference.resolve());
   }
 
+  public void testNavigationFromMainToFxml() throws Exception {
+    configureByFiles(null, getTestName(false) + ".java", getTestName(true) + ".fxml");
+    final int offset = myEditor.getCaretModel().getOffset();
+    final PsiReference reference = myFile.findReferenceAt(offset);
+    assertNotNull(reference);
+    final PsiElement resolve = reference.resolve();
+    assertNotNull(resolve);
+    final PsiFile containingFile = resolve.getContainingFile();
+    assertNotNull(containingFile);
+    assertEquals(getTestName(true) + ".fxml", containingFile.getName());
+  }
+
   public void testSourceAttrRecognition() throws Exception {
     doTest();
   }
diff --git a/plugins/javaFX/javaFX.iml b/plugins/javaFX/javaFX.iml
index 62b68b155832..2a8f125eb754 100644
--- a/plugins/javaFX/javaFX.iml
+++ b/plugins/javaFX/javaFX.iml
@@ -17,6 +17,7 @@
     <orderEntry type="module" module-name="xml" />
     <orderEntry type="module" module-name="java-impl" />
     <orderEntry type="module" module-name="java-indexing-api" />
+    <orderEntry type="module" module-name="openapi" />
   </component>
 </module>
 
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index c0ba7df0fc0b..4ddebeb1b51d 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -25,6 +25,7 @@
       <category>JavaFX</category>
     </intentionAction>
     <lang.importOptimizer language="XML" implementationClass="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer" order="before XML"/>
+    <psi.referenceContributor implementation="org.jetbrains.plugins.javaFX.fxml.refs.JavaFxReferencesContributor"/>
   </extensions>
 
   <actions>
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxCommonClassNames.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxCommonClassNames.java
index db043d8ea2f7..73e2d9af1850 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxCommonClassNames.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxCommonClassNames.java
@@ -34,4 +34,5 @@ public class JavaFxCommonClassNames {
   @NonNls public static final String JAVAFX_FXML_BUILDER = "javafx.util.Builder";
   @NonNls public static final String JAVAFX_BEANS_OBSERVABLE = "javafx.beans.Observable";
   @NonNls public static final String VALUE_OF = "valueOf";
+  @NonNls public static final String JAVAFX_FXML_FXMLLOADER = "javafx.fxml.FXMLLoader";
 }
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
new file mode 100644
index 000000000000..ab1cfcb22880
--- /dev/null
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml.refs;
+
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.openapi.vfs.newvfs.NewVirtualFileSystem;
+import com.intellij.psi.*;
+import com.intellij.psi.filters.ElementFilter;
+import com.intellij.psi.filters.position.FilterPattern;
+import com.intellij.psi.impl.source.resolve.reference.impl.providers.FileReferenceSet;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.util.PsiUtil;
+import com.intellij.util.ProcessingContext;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.javaFX.fxml.JavaFxCommonClassNames;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import static com.intellij.patterns.PsiJavaPatterns.literalExpression;
+
+/**
+ * User: anna
+ * Date: 2/22/13
+ */
+public class JavaFxReferencesContributor extends PsiReferenceContributor {
+
+  @Override
+  public void registerReferenceProviders(PsiReferenceRegistrar registrar) {
+    registrar.registerReferenceProvider(literalExpression().and(new FilterPattern(new ElementFilter() {
+      public boolean isAcceptable(Object element, PsiElement context) {
+        final PsiLiteralExpression literalExpression = (PsiLiteralExpression)context;
+        PsiMethodCallExpression callExpression = PsiTreeUtil.getParentOfType(literalExpression, PsiMethodCallExpression.class);
+        if (callExpression != null && "getResource".equals(callExpression.getMethodExpression().getReferenceName())) {
+          final PsiMethodCallExpression superCall = PsiTreeUtil.getParentOfType(callExpression, PsiMethodCallExpression.class, true);
+          if (superCall != null) {
+            final PsiReferenceExpression methodExpression = superCall.getMethodExpression();
+            if ("load".equals(methodExpression.getReferenceName())) {
+              final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
+              PsiClass psiClass = null;
+              if (qualifierExpression instanceof PsiReferenceExpression) {
+                final PsiElement resolve = ((PsiReferenceExpression)qualifierExpression).resolve();
+                if (resolve instanceof PsiClass) {
+                  psiClass = (PsiClass)resolve;
+                }
+              } else if (qualifierExpression != null) {
+                psiClass = PsiUtil.resolveClassInType(qualifierExpression.getType());
+              }
+              if (psiClass != null && JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER.equals(psiClass.getQualifiedName())) {
+                return true;
+              }
+            }
+          }
+        }
+        return false;
+      }
+
+      public boolean isClassAcceptable(Class hintClass) {
+        return true;
+      }
+    })), new PsiReferenceProvider() {
+      @NotNull
+      @Override
+      public PsiReference[] getReferencesByElement(@NotNull final PsiElement element, @NotNull ProcessingContext context) {
+        final Object value = ((PsiLiteralExpression)element).getValue();
+        final PsiDirectory directory = element.getContainingFile().getParent();
+        if (!(value instanceof String) || directory == null) return PsiReference.EMPTY_ARRAY;
+        final VirtualFileSystem fs = directory.getVirtualFile().getFileSystem();
+        return new FileReferenceSet((String)value, element, 1, null, ((NewVirtualFileSystem)fs).isCaseSensitive()) {
+          @NotNull
+          @Override
+          public Collection<PsiFileSystemItem> getDefaultContexts() {
+            if (!directory.isValid()) {
+              return super.getDefaultContexts();
+            }
+            return Collections.<PsiFileSystemItem>singletonList(directory);
+          }
+        }.getAllReferences();
+      }
+    });
+  }
+}
diff --git a/plugins/javaFX/testData/highlighting/NavigationFromMainToFxml.java b/plugins/javaFX/testData/highlighting/NavigationFromMainToFxml.java
new file mode 100644
index 000000000000..707140ca7c04
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/NavigationFromMainToFxml.java
@@ -0,0 +1,21 @@
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+public class Main extends Application {
+
+    @Override
+    public void start(Stage primaryStage) throws Exception{
+        Parent root = FXMLLoader.load(getClass().getResource("navi<caret>gationFromMainToFxml.fxml"));
+        primaryStage.setTitle("Hello World");
+        primaryStage.setScene(new Scene(root, 300, 275));
+        primaryStage.show();
+    }
+
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}
diff --git a/plugins/javaFX/testData/highlighting/navigationFromMainToFxml.fxml b/plugins/javaFX/testData/highlighting/navigationFromMainToFxml.fxml
new file mode 100644
index 000000000000..41c1c69d1ff5
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/navigationFromMainToFxml.fxml
@@ -0,0 +1,2 @@
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml"/>
\ No newline at end of file

From 279f850590852c55350c7c70cb1257fff80487fd Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 21:58:22 +0100
Subject: [PATCH 070/354] provide extension to xml import optimizers

---
 platform/platform-resources/src/META-INF/XmlPlugin.xml    | 1 +
 plugins/javaFX/src/META-INF/common-javaFX-plugin.xml      | 2 +-
 .../src/com/intellij/refactoring/XmlImportOptimizer.java  | 8 ++++++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/platform/platform-resources/src/META-INF/XmlPlugin.xml b/platform/platform-resources/src/META-INF/XmlPlugin.xml
index e0eb126d1335..6eed810dd60a 100644
--- a/platform/platform-resources/src/META-INF/XmlPlugin.xml
+++ b/platform/platform-resources/src/META-INF/XmlPlugin.xml
@@ -74,6 +74,7 @@
                     beanClass="com.intellij.lang.LanguageExtensionPoint">
       <with attribute="implementationClass" implements="com.intellij.lang.HtmlInlineScriptTokenTypesProvider"/>
     </extensionPoint>
+    <extensionPoint name="xml.importOptimizer" interface="com.intellij.lang.ImportOptimizer"/>
   </extensionPoints>
 
   <project-components>
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index 4ddebeb1b51d..c1e8699fea9b 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -24,7 +24,7 @@
       <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxCollapseSubTagToAttributeIntention</className>
       <category>JavaFX</category>
     </intentionAction>
-    <lang.importOptimizer language="XML" implementationClass="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer" order="before XML"/>
+    <xml.importOptimizer implementation="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer"/>
     <psi.referenceContributor implementation="org.jetbrains.plugins.javaFX.fxml.refs.JavaFxReferencesContributor"/>
   </extensions>
 
diff --git a/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java b/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
index 3803b16057ec..d27dc2bb95b5 100644
--- a/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
+++ b/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
@@ -21,6 +21,8 @@ import com.intellij.codeInspection.ProblemDescriptor;
 import com.intellij.codeInspection.ProblemsHolder;
 import com.intellij.codeInspection.QuickFix;
 import com.intellij.lang.ImportOptimizer;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Condition;
 import com.intellij.psi.*;
@@ -40,6 +42,7 @@ import java.util.Map;
  *         Date: 11/7/11
  */
 public class XmlImportOptimizer implements ImportOptimizer {
+  public static final ExtensionPointName<ImportOptimizer> EP_NAME = ExtensionPointName.create("com.intellij.xml.importOptimizer");
 
   private final XmlUnusedNamespaceInspection myInspection = new XmlUnusedNamespaceInspection();
   private final Condition<ProblemDescriptor> myCondition = new Condition<ProblemDescriptor>() {
@@ -59,6 +62,11 @@ public class XmlImportOptimizer implements ImportOptimizer {
   @NotNull
   @Override
   public Runnable processFile(final PsiFile file) {
+    for (ImportOptimizer optimizer : Extensions.getExtensions(EP_NAME)) {
+      if (optimizer.supports(file)) {
+        return optimizer.processFile(file);
+      }
+    }
     return new Runnable() {
       @Override
       public void run() {

From 4dba7f4b15aff9867f488eee513ec482e36a74fc Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Fri, 22 Feb 2013 22:29:12 +0100
Subject: [PATCH 071/354] javafx: open in scene builder: allow to select path
 to scene builder on action execution

---
 .../javaFX/JavaFxSettingsConfigurable.java     | 13 ++++++++++---
 .../actions/OpenInSceneBuilderAction.java      | 18 ++++++++++++++----
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/JavaFxSettingsConfigurable.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/JavaFxSettingsConfigurable.java
index 57c1e00f4e34..8ad083de7820 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/JavaFxSettingsConfigurable.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/JavaFxSettingsConfigurable.java
@@ -15,6 +15,7 @@
  */
 package org.jetbrains.plugins.javaFX;
 
+import com.intellij.openapi.fileChooser.FileChooserDescriptor;
 import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
 import com.intellij.openapi.options.Configurable;
 import com.intellij.openapi.options.ConfigurationException;
@@ -93,14 +94,20 @@ public class JavaFxSettingsConfigurable implements SearchableConfigurable, Confi
     return null;
   }
 
+  public static FileChooserDescriptor createSceneBuilderDescriptor() {
+    final FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor();
+    descriptor.setTitle("SceneBuilder Configuration");
+    descriptor.setDescription("Select path to SceneBuilder executable");
+    return descriptor;
+  }
 
   public static class JavaFxConfigurablePanel {
     private TextFieldWithBrowseButton myPathField;
     private JPanel myWholePanel;
 
     public JavaFxConfigurablePanel() {
-      myPathField.addBrowseFolderListener("SceneBuilder Configuration", "Select path to SceneBuilder executable", null,
-                                          FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor());
+      final FileChooserDescriptor descriptor = createSceneBuilderDescriptor();
+      myPathField.addBrowseFolderListener(descriptor.getTitle(), descriptor.getDescription(), null, descriptor);
     }
 
     private void reset(JavaFxSettings settings) {
@@ -111,7 +118,7 @@ public class JavaFxSettingsConfigurable implements SearchableConfigurable, Confi
     }
 
     private void apply(JavaFxSettings settings) {
-      settings.setPathToSceneBuilder(FileUtil.toSystemIndependentName(myPathField.getText()));
+      settings.setPathToSceneBuilder(FileUtil.toSystemIndependentName(myPathField.getText().trim()));
     }
 
     private boolean isModified(JavaFxSettings settings) {
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/actions/OpenInSceneBuilderAction.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/actions/OpenInSceneBuilderAction.java
index f0e21bcf3c67..c342891ae51b 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/actions/OpenInSceneBuilderAction.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/actions/OpenInSceneBuilderAction.java
@@ -23,12 +23,14 @@ import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
 import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.fileChooser.FileChooser;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.plugins.javaFX.JavaFxSettings;
+import org.jetbrains.plugins.javaFX.JavaFxSettingsConfigurable;
 import org.jetbrains.plugins.javaFX.fxml.JavaFxFileTypeFactory;
 
 /**
@@ -44,8 +46,16 @@ public class OpenInSceneBuilderAction extends AnAction {
     LOG.assertTrue(virtualFile != null);
     final String path = virtualFile.getPath();
 
-    String pathToSceneBuilder = JavaFxSettings.getInstance().getPathToSceneBuilder();
-    LOG.assertTrue(pathToSceneBuilder != null);
+    final JavaFxSettings settings = JavaFxSettings.getInstance();
+    String pathToSceneBuilder = settings.getPathToSceneBuilder();
+    if (StringUtil.isEmptyOrSpaces(settings.getPathToSceneBuilder())){
+      final VirtualFile sceneBuilderFile = FileChooser.chooseFile(JavaFxSettingsConfigurable.createSceneBuilderDescriptor(), e.getProject(), null);
+      if (sceneBuilderFile == null) return;
+
+      pathToSceneBuilder = sceneBuilderFile.getPath();
+      settings.setPathToSceneBuilder(FileUtil.toSystemIndependentName(pathToSceneBuilder));
+    }
+
     if (SystemInfo.isMac) {
       pathToSceneBuilder += "/Contents/MacOS/JavaAppLauncher";
     }
@@ -68,8 +78,8 @@ public class OpenInSceneBuilderAction extends AnAction {
     presentation.setVisible(false);
     final VirtualFile virtualFile = e.getData(PlatformDataKeys.VIRTUAL_FILE);
     if (virtualFile != null && 
-        JavaFxFileTypeFactory.isFxml(virtualFile) && 
-        !StringUtil.isEmptyOrSpaces(JavaFxSettings.getInstance().getPathToSceneBuilder())) {
+        JavaFxFileTypeFactory.isFxml(virtualFile) &&
+        e.getProject() != null) {
       presentation.setEnabled(true);
       presentation.setVisible(true);
     }

From 71b85324cf69680d11782fd8e39aeb996c372af4 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Fri, 22 Feb 2013 10:43:04 +0100
Subject: [PATCH 072/354] Formatting

---
 .../openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java      | 5 +++--
 .../openapi/vfs/newvfs/impl/VirtualFileSystemEntry.java    | 7 +++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
index c3755c8f90f3..cfbbe4319639 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -65,7 +65,8 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
   // stores child files. The array is logically divided into the two parts:
   // left subarray for storing real files, right subarray for storing fake files with "suspicious" names
   // files in each subarray are sorted according to the compareNameTo() comparator
-  private VirtualFileSystemEntry[] myChildren = EMPTY_ARRAY; // guarded by this, either real file or fake file (meaning it's not a real child but suspicious name)
+  // guarded by this, either real file or fake file (meaning it's not a real child but suspicious name)
+  private VirtualFileSystemEntry[] myChildren = EMPTY_ARRAY;
 
   public VirtualDirectoryImpl(@NonNls @NotNull final String name,
                               @Nullable final VirtualDirectoryImpl parent,
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileSystemEntry.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileSystemEntry.java
index 25e054e9e082..c9d9c7881d50 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileSystemEntry.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileSystemEntry.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -60,7 +60,10 @@ public abstract class VirtualFileSystemEntry extends NewVirtualFile {
   private static final int INT_FLAGS_MASK = 0xff00;
 
   private static final String EMPTY = "";
-  @NonNls private static final String[] WELL_KNOWN_SUFFIXES = {"$1.class", "$2.class","Test.java","List.java","tion.java", ".class", ".java", ".html", ".txt", ".xml",".php",".gif",".svn",".css",".js"};
+  @NonNls private static final String[] WELL_KNOWN_SUFFIXES = {
+    "$1.class", "$2.class", "Test.java", "List.java", "tion.java", ".class",
+    ".java", ".html", ".txt", ".xml", ".php", ".gif", ".svn", ".css", ".js"
+  };
   private static final byte[][] WELL_KNOWN_SUFFIXES_BYTES;
   private static final int[] WELL_KNOWN_SUFFIXES_LENGTH;
   private static final int SUFFIX_BITS = 4;

From cb2b94071b7c551ac066234042d5c831feb19fed Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Fri, 22 Feb 2013 11:26:17 +0100
Subject: [PATCH 073/354] Duplication

---
 .../intellij/psi/impl/source/tree/java/ClassElement.java | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ClassElement.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ClassElement.java
index e3830e5d6be8..8b33ab278903 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ClassElement.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ClassElement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -214,7 +214,7 @@ public class ClassElement extends CompositeElement implements Constants {
         }
       }
     }
-    
+
     super.deleteChildInternal(child);
   }
 
@@ -364,7 +364,7 @@ public class ClassElement extends CompositeElement implements Constants {
     else if (i == JavaDocElementType.DOC_COMMENT) {
       return getChildRole(child, ChildRole.DOC_COMMENT);
     }
-    else if (i == C_STYLE_COMMENT || i == END_OF_LINE_COMMENT) {
+    else if (ElementType.JAVA_PLAIN_COMMENT_BIT_SET.contains(i)) {
       return ChildRoleBase.NONE;
     }
     else if (i == MODIFIER_LIST) {
@@ -376,7 +376,7 @@ public class ClassElement extends CompositeElement implements Constants {
     else if (i == IMPLEMENTS_LIST) {
       return ChildRole.IMPLEMENTS_LIST;
     }
-    else if (i == CLASS_KEYWORD || i == INTERFACE_KEYWORD || i == ENUM_KEYWORD) {
+    else if (ElementType.CLASS_KEYWORD_BIT_SET.contains(i)) {
       return getChildRole(child, ChildRole.CLASS_OR_INTERFACE_KEYWORD);
     }
     else if (i == IDENTIFIER) {
@@ -403,5 +403,4 @@ public class ClassElement extends CompositeElement implements Constants {
   protected boolean isVisibilitySupported() {
     return true;
   }
-
 }

From 98ab825b15079406b969ff7b802d5a8188304d26 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Fri, 22 Feb 2013 12:09:20 +0100
Subject: [PATCH 074/354] Cleanup (obsolete common constants)

---
 .../psi/impl/source/PsiImportListImpl.java    | 14 +++++++----
 .../psi/impl/source/tree/ElementType.java     |  6 +----
 .../java/PsiReferenceParameterListImpl.java   |  4 +--
 .../tree/java/PsiTypeParameterImpl.java       | 25 +++++++++++--------
 4 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiImportListImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiImportListImpl.java
index 05b5a6b86a1f..b49a615f0285 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiImportListImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiImportListImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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,8 +20,10 @@ import com.intellij.psi.*;
 import com.intellij.psi.impl.java.stubs.JavaStubElementTypes;
 import com.intellij.psi.impl.java.stubs.PsiImportListStub;
 import com.intellij.psi.impl.source.tree.ElementType;
-import com.intellij.util.containers.HashMap;
+import com.intellij.psi.impl.source.tree.JavaElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.ArrayFactory;
+import com.intellij.util.containers.HashMap;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
@@ -63,17 +65,19 @@ public class PsiImportListImpl extends JavaStubPsiElement<PsiImportListStub> imp
     super.subtreeChanged();
   }
 
+  private static final TokenSet IMPORT_STATEMENT_BIT_SET = TokenSet.create(JavaElementType.IMPORT_STATEMENT);
+  private static final TokenSet IMPORT_STATIC_STATEMENT_BIT_SET = TokenSet.create(JavaElementType.IMPORT_STATIC_STATEMENT);
+
   @Override
   @NotNull
   public PsiImportStatement[] getImportStatements() {
-    return getStubOrPsiChildren(ElementType.IMPORT_STATEMENT_BIT_SET, PsiImportStatementImpl.ARRAY_FACTORY);
+    return getStubOrPsiChildren(IMPORT_STATEMENT_BIT_SET, PsiImportStatementImpl.ARRAY_FACTORY);
   }
 
   @Override
   @NotNull
   public PsiImportStaticStatement[] getImportStaticStatements() {
-    return getStubOrPsiChildren(ElementType.IMPORT_STATIC_STATEMENT_BIT_SET, PsiImportStaticStatementImpl.ARRAY_FACTORY);
-
+    return getStubOrPsiChildren(IMPORT_STATIC_STATEMENT_BIT_SET, PsiImportStaticStatementImpl.ARRAY_FACTORY);
   }
 
   @Override
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java
index eb8328047d1e..b61fb3d147f5 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -70,12 +70,8 @@ public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElemen
     WHILE_STATEMENT, FOR_STATEMENT, FOREACH_STATEMENT, DO_WHILE_STATEMENT, SWITCH_STATEMENT, SWITCH_LABEL_STATEMENT, BREAK_STATEMENT,
     CONTINUE_STATEMENT, RETURN_STATEMENT, THROW_STATEMENT, SYNCHRONIZED_STATEMENT, TRY_STATEMENT, LABELED_STATEMENT, ASSERT_STATEMENT);
 
-  TokenSet TYPES_BIT_SET = TokenSet.create(TYPE);
-  TokenSet IMPORT_STATEMENT_BIT_SET = TokenSet.create(IMPORT_STATEMENT);
-  TokenSet IMPORT_STATIC_STATEMENT_BIT_SET = TokenSet.create(IMPORT_STATIC_STATEMENT);
   TokenSet IMPORT_STATEMENT_BASE_BIT_SET = TokenSet.create(IMPORT_STATEMENT, IMPORT_STATIC_STATEMENT);
   TokenSet CLASS_KEYWORD_BIT_SET = TokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD, ENUM_KEYWORD);
   TokenSet MEMBER_BIT_SET = TokenSet.create(CLASS, FIELD, ENUM_CONSTANT, METHOD, ANNOTATION_METHOD);
   TokenSet FULL_MEMBER_BIT_SET = TokenSet.orSet(MEMBER_BIT_SET, TokenSet.create(CLASS_INITIALIZER));
-  TokenSet ANNOTATIONS = TokenSet.create(ANNOTATION);
 }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceParameterListImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceParameterListImpl.java
index 0cdbf5c21e5a..e85e81cb4bd8 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceParameterListImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceParameterListImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -38,7 +38,7 @@ public class PsiReferenceParameterListImpl extends CompositePsiElement implement
   @Override
   @NotNull
   public PsiTypeElement[] getTypeParameterElements() {
-    return getChildrenAsPsiElements(ElementType.TYPES_BIT_SET, PsiTypeElement.ARRAY_FACTORY);
+    return getChildrenAsPsiElements(JavaElementType.TYPE, PsiTypeElement.ARRAY_FACTORY);
   }
 
   @Override
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiTypeParameterImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiTypeParameterImpl.java
index d56a69b0bfb7..12bc9fb34ca2 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiTypeParameterImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiTypeParameterImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -28,8 +28,6 @@ import com.intellij.psi.impl.java.stubs.PsiTypeParameterStub;
 import com.intellij.psi.impl.light.LightEmptyImplementsList;
 import com.intellij.psi.impl.meta.MetaRegistry;
 import com.intellij.psi.impl.source.JavaStubPsiElement;
-import com.intellij.psi.impl.source.tree.ChildRole;
-import com.intellij.psi.impl.source.tree.ElementType;
 import com.intellij.psi.javadoc.PsiDocComment;
 import com.intellij.psi.meta.PsiMetaData;
 import com.intellij.psi.scope.PsiScopeProcessor;
@@ -44,7 +42,7 @@ import java.util.Collection;
 import java.util.List;
 
 /**
- *  @author dsl
+ * @author dsl
  */
 public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStub> implements PsiTypeParameter {
   private final LightEmptyImplementsList myLightEmptyImplementsList = new LightEmptyImplementsList(null) {
@@ -169,7 +167,7 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
       return PsiTreeUtil.getParentOfType(this, PsiTypeParameterListOwner.class);
     }
 
-    return (PsiTypeParameterListOwner) parentParent;
+    return (PsiTypeParameterListOwner)parentParent;
   }
 
 
@@ -183,9 +181,10 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
 
     int ret = 0;
     PsiElement element = getPrevSibling();
-    while(element != null){
-      if(element instanceof PsiTypeParameter)
+    while (element != null) {
+      if (element instanceof PsiTypeParameter) {
         ret++;
+      }
       element = element.getPrevSibling();
     }
     return ret;
@@ -194,11 +193,14 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
   @Override
   @NotNull
   public PsiIdentifier getNameIdentifier() {
-    return (PsiIdentifier) calcTreeElement().findChildByRole(ChildRole.NAME);
+    return PsiTreeUtil.getRequiredChildOfType(this, PsiIdentifier.class);
   }
 
   @Override
-  public boolean processDeclarations(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent, @NotNull PsiElement place){
+  public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
+                                     @NotNull ResolveState state,
+                                     PsiElement lastParent,
+                                     @NotNull PsiElement place) {
     return PsiClassImplUtil.processDeclarationsInClass(this, processor, state, null, lastParent, place, false);
   }
 
@@ -361,7 +363,7 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
     return "PsiTypeParameter:" + getName();
   }
 
-  public PsiMetaData getMetaData(){
+  public PsiMetaData getMetaData() {
     return MetaRegistry.getMeta(this);
   }
 
@@ -384,7 +386,7 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
   @Override
   @NotNull
   public PsiAnnotation[] getAnnotations() {
-    return getStubOrPsiChildren(ElementType.ANNOTATIONS, PsiAnnotation.ARRAY_FACTORY);
+    return getStubOrPsiChildren(JavaStubElementTypes.ANNOTATION, PsiAnnotation.ARRAY_FACTORY);
   }
 
   @Override
@@ -397,6 +399,7 @@ public class PsiTypeParameterImpl extends JavaStubPsiElement<PsiTypeParameterStu
   public PsiAnnotation addAnnotation(@NotNull @NonNls String qualifiedName) {
     throw new IncorrectOperationException();
   }
+
   @Override
   @NotNull
   public PsiAnnotation[] getApplicableAnnotations() {

From 58b01db68a1a8a64c1ce7157ec0145496b1754ea Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Fri, 22 Feb 2013 22:03:12 +0100
Subject: [PATCH 075/354] Formatting

---
 .../com/intellij/util/containers/Queue.java   | 40 +++++++++++--------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/platform/util/src/com/intellij/util/containers/Queue.java b/platform/util/src/com/intellij/util/containers/Queue.java
index cf73a493e961..96630491fbf5 100644
--- a/platform/util/src/com/intellij/util/containers/Queue.java
+++ b/platform/util/src/com/intellij/util/containers/Queue.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -26,7 +26,6 @@ public class Queue<T> {
   private Object[] myArray;
   private int myFirst;
   private int myLast;
-
   // if true, elements are located at myFirst..myArray.length and 0..myLast
   // otherwise, they are at myFirst..myLast
   private boolean isWrapped;
@@ -50,18 +49,18 @@ public class Queue<T> {
       myLast = 0;
     }
   }
-  
+
   public T removeLast() {
     if (myLast == 0) {
       isWrapped = !isWrapped;
       myLast = myArray.length;
     }
     myLast--;
-    T result = (T)myArray[myLast];
+    @SuppressWarnings("unchecked") T result = (T)myArray[myLast];
     myArray[myLast] = null;
     return result;
   }
-  
+
 
   public boolean isEmpty() {
     return size() == 0;
@@ -94,17 +93,18 @@ public class Queue<T> {
     if (isEmpty()) {
       throw new IndexOutOfBoundsException("queue is empty");
     }
-    return (T)myArray[myFirst];
+    @SuppressWarnings("unchecked") T t = (T)myArray[myFirst];
+    return t;
   }
 
-  private int copyFromTo(int first, int last, T[] result, int destPos) {
+  private int copyFromTo(int first, int last, Object[] result, int destinationPos) {
     int length = last - first;
-    System.arraycopy(myArray, first, result, destPos, length);
+    System.arraycopy(myArray, first, result, destinationPos, length);
     return length;
   }
 
   private T[] normalize(int capacity) {
-    T[] result = (T[])new Object[capacity];
+    @SuppressWarnings("unchecked") T[] result = (T[])new Object[capacity];
     if (isWrapped) {
       int tailLength = copyFromTo(myFirst, myArray.length, result, 0);
       copyFromTo(0, myLast, result, tailLength);
@@ -127,31 +127,33 @@ public class Queue<T> {
       if (myFirst + index >= myArray.length) {
         arrayIndex = index - myArray.length + myFirst;
       }
-      else
+      else {
         arrayIndex = myFirst + index;
+      }
     }
     else {
       arrayIndex = myFirst + index;
     }
     final Object old = myArray[arrayIndex];
     myArray[arrayIndex] = value;
-    return (T)old;
+    @SuppressWarnings("unchecked") T t = (T)old;
+    return t;
   }
 
   public boolean process(@NotNull Processor<T> processor) {
     if (isWrapped) {
       for (int i = myFirst; i < myArray.length; i++) {
-        T t = (T)myArray[i];
+        @SuppressWarnings("unchecked") T t = (T)myArray[i];
         if (!processor.process(t)) return false;
       }
       for (int i = 0; i < myLast; i++) {
-        T t = (T)myArray[i];
+        @SuppressWarnings("unchecked") T t = (T)myArray[i];
         if (!processor.process(t)) return false;
       }
     }
     else {
       for (int i = myFirst; i < myLast; i++) {
-        T t = (T)myArray[i];
+        @SuppressWarnings("unchecked") T t = (T)myArray[i];
         if (!processor.process(t)) return false;
       }
     }
@@ -163,8 +165,14 @@ public class Queue<T> {
     if (isEmpty()) return "<empty>";
     List<Object> list = Arrays.asList(myArray);
     if (isWrapped) {
-      return "[[[ " +list.subList(0, myLast) + " ||| ... " + list.subList(myLast, myFirst) + " ... ||| " + list.subList(myFirst, myArray.length) + " ]]]";
+      return "[[[ " + list.subList(0, myLast) + " ||| ... " +
+             list.subList(myLast, myFirst) + " ... ||| " +
+             list.subList(myFirst, myArray.length) + " ]]]";
+    }
+    else {
+      return "[[[ ... " + list.subList(0, myFirst) + " ... ||| " +
+                 list.subList(myFirst, myLast) + " ||| ... " +
+                 list.subList(myFirst, myArray.length) + " ... ]]]";
     }
-    return "[[[ ... " +list.subList(0, myFirst) + " ... ||| " + list.subList(myFirst, myLast) + " ||| ... " + list.subList(myFirst, myArray.length) + " ... ]]]";
   }
 }

From 812d97634de2f44b1836cbf34fc2767ed98177b8 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Fri, 22 Feb 2013 22:04:13 +0100
Subject: [PATCH 076/354] Utility methods

---
 .../com/intellij/util/containers/Stack.java    | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/platform/util-rt/src/com/intellij/util/containers/Stack.java b/platform/util-rt/src/com/intellij/util/containers/Stack.java
index da0e9d8a99ac..966b89010725 100644
--- a/platform/util-rt/src/com/intellij/util/containers/Stack.java
+++ b/platform/util-rt/src/com/intellij/util/containers/Stack.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,6 +15,8 @@
  */
 package com.intellij.util.containers;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.*;
 
 /**
@@ -32,7 +34,10 @@ public class Stack<T> extends ArrayList<T> {
     super(init);
   }
 
-  public Stack() {
+  public Stack(T... items) {
+    for (T item : items) {
+      push(item);
+    }
   }
 
   public void push(T t) {
@@ -51,6 +56,11 @@ public class Stack<T> extends ArrayList<T> {
     return remove(size - 1);
   }
 
+  @Nullable
+  public T tryPop() {
+    return isEmpty() ? null : pop();
+  }
+
   public boolean empty() {
     return isEmpty();
   }
@@ -58,7 +68,7 @@ public class Stack<T> extends ArrayList<T> {
   @Override
   public boolean equals(Object o) {
     if (o instanceof RandomAccess && o instanceof List) {
-      List other = (List) o;
+      List other = (List)o;
       if (size() != other.size()) {
         return false;
       }
@@ -66,7 +76,7 @@ public class Stack<T> extends ArrayList<T> {
       for (int i = 0; i < other.size(); i++) {
         Object o1 = other.get(i);
         Object o2 = get(i);
-        if (!(o1==null ? o2==null : o1.equals(o2))) {
+        if (!(o1 == null ? o2 == null : o1.equals(o2))) {
           return false;
         }
       }

From ed7abec75e3efec39fde332201a485bb26abb28d Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 22 Feb 2013 23:12:02 +0100
Subject: [PATCH 077/354] log.debug dfa inspection

---
 .../com/intellij/codeInspection/dataFlow/DataFlowRunner.java  | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
index dd5183d451d8..94c628ff0f1d 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
@@ -144,7 +144,9 @@ public class DataFlowRunner {
           }
         }
 
-        //System.out.println(instructionState);
+        if (LOG.isDebugEnabled()) {
+          LOG.debug(instructionState.toString());
+        }
 
         DfaInstructionState[] after = instruction.accept(this, instructionState.getMemoryState(), visitor);
         if (after != null) {

From fd80f6c26d74c0b37196c0ab056161effa92e2c1 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Fri, 22 Feb 2013 17:13:59 +0400
Subject: [PATCH 078/354] IDEA-100100 Groovy 2.1: applicability of annotation
 aliases is not checked if annotations are passed to @AnnotationCollector as a
 list

---
 .../annotator/GrAliasAnnotationChecker.java   | 33 +++-------
 .../groovy/annotator/GroovyAnnotator.java     |  2 +-
 .../GrAnnotationNameValuePairImpl.java        | 14 +++--
 .../modifiers/GrAnnotationCollector.java      | 23 +++++--
 .../GrAnnotationHighlightingTest.groovy       | 62 ++++++++++++++++++-
 .../GroovyHighlightingTest.groovy             | 39 ------------
 6 files changed, 96 insertions(+), 77 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GrAliasAnnotationChecker.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GrAliasAnnotationChecker.java
index a379b76cda3b..fc1071d13a40 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GrAliasAnnotationChecker.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GrAliasAnnotationChecker.java
@@ -21,12 +21,9 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.GroovyBundle;
-import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationNameValuePair;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
 import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
 import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrAnnotationCollector;
 import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
@@ -39,32 +36,20 @@ import java.util.Set;
  * @author Max Medvedev
  */
 public class GrAliasAnnotationChecker extends CustomAnnotationChecker {
-  @Nullable
-  private static GrTypeDefinition resolveAlias(@NotNull GrAnnotation annotation) {
-    final GrCodeReferenceElement ref = annotation.getClassReference();
-
-    final PsiElement resolved = ref.resolve();
-    if (GrAnnotationCollector.findAnnotationCollector(resolved) != null) {
-      assert resolved instanceof GrTypeDefinition;
-      return ((GrTypeDefinition)(resolved));
-    }
-
-
-    return null;
-  }
 
   @Override
   public boolean checkApplicability(@NotNull AnnotationHolder holder, @NotNull GrAnnotation annotation) {
-    final GrTypeDefinition alias = resolveAlias(annotation);
-    if (alias == null) {
+    final GrAnnotation annotationCollector = GrAnnotationCollector.findAnnotationCollector(annotation);
+    if (annotationCollector == null) {
       return false;
     }
 
     final GrCodeReferenceElement ref = annotation.getClassReference();
 
-    final GrModifierList list = alias.getModifierList();
-    assert list != null;
-    for (GrAnnotation anno : list.getRawAnnotations()) {
+    final ArrayList<GrAnnotation> aliasedAnnotations = ContainerUtil.newArrayList();
+    GrAnnotationCollector.collectAnnotations(aliasedAnnotations, annotation, annotationCollector);
+
+    for (GrAnnotation anno : aliasedAnnotations) {
       if (GroovyCommonClassNames.GROOVY_TRANSFORM_ANNOTATION_COLLECTOR.equals(anno.getQualifiedName())) continue;
       final String description = CustomAnnotationChecker.isAnnotationApplicable(anno, annotation.getParent());
       if (description != null) {
@@ -77,14 +62,12 @@ public class GrAliasAnnotationChecker extends CustomAnnotationChecker {
 
   @Override
   public boolean checkArgumentList(@NotNull AnnotationHolder holder, @NotNull GrAnnotation annotation) {
-    final GrTypeDefinition alias = resolveAlias(annotation);
-    if (alias == null) {
+    final GrAnnotation annotationCollector = GrAnnotationCollector.findAnnotationCollector(annotation);
+    if (annotationCollector == null) {
       return false;
     }
 
     final ArrayList<GrAnnotation> annotations = ContainerUtil.newArrayList();
-    final GrAnnotation annotationCollector = GrAnnotationCollector.findAnnotationCollector(alias);
-    assert annotationCollector != null;
     final Set<String> usedAttributes = GrAnnotationCollector.collectAnnotations(annotations, annotation, annotationCollector);
 
     final GrCodeReferenceElement ref = annotation.getClassReference();
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
index 8e1810d0a3dc..bc09365a7ce3 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
@@ -799,7 +799,7 @@ public class GroovyAnnotator extends GroovyElementVisitor implements Annotator {
     PsiElement resolved = refElement.resolve();
     if (resolved instanceof PsiClass &&
         (((PsiClass)resolved).isAnnotationType() ||
-                                         GrAnnotationCollector.findAnnotationCollector(resolved) != null &&
+                                         GrAnnotationCollector.findAnnotationCollector((PsiClass)resolved) != null &&
                                          refElement.getParent() instanceof GrAnnotation)) {
       myHolder.createInfoAnnotation(refElement, null).setTextAttributes(ANNOTATION);
     }
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationNameValuePairImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationNameValuePairImpl.java
index 85ecc72a93ad..3d074c17f6c0 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationNameValuePairImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationNameValuePairImpl.java
@@ -178,13 +178,15 @@ public class GrAnnotationNameValuePairImpl extends GroovyPsiElementImpl implemen
       String declaredName = getName();
       String name = declaredName == null ? PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME : declaredName;
 
-      final GrAnnotation collector = GrAnnotationCollector.findAnnotationCollector(resolved);
-      if (collector != null) {
-        return multiResolveFromAlias(annotation, name, collector);
-      }
+      if (resolved instanceof PsiClass) {
+        final GrAnnotation collector = GrAnnotationCollector.findAnnotationCollector((PsiClass)resolved);
+        if (collector != null) {
+          return multiResolveFromAlias(annotation, name, collector);
+        }
 
-      if (resolved instanceof PsiClass && ((PsiClass)resolved).isAnnotationType()) {
-        return multiResolveFromAnnotationType((PsiClass)resolved, name);
+        if (((PsiClass)resolved).isAnnotationType()) {
+          return multiResolveFromAnnotationType((PsiClass)resolved, name);
+        }
       }
     }
     return GroovyResolveResult.EMPTY_ARRAY;
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/GrAnnotationCollector.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/GrAnnotationCollector.java
index 0175323e7e9d..7b9710e932e4 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/GrAnnotationCollector.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/modifiers/GrAnnotationCollector.java
@@ -26,6 +26,7 @@ import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationNameValuePair;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition;
+import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
 
@@ -42,8 +43,7 @@ public class GrAnnotationCollector {
 
     List<GrAnnotation> result = ContainerUtil.newArrayList();
     for (GrAnnotation annotation : rawAnnotations) {
-      final PsiElement resolved = annotation.getClassReference().resolve();
-      final GrAnnotation annotationCollector = findAnnotationCollector(resolved);
+      final GrAnnotation annotationCollector = findAnnotationCollector(annotation);
       if (annotationCollector != null) {
         collectAnnotations(result, annotation, annotationCollector);
       }
@@ -58,8 +58,7 @@ public class GrAnnotationCollector {
 
   private static boolean hasAliases(GrAnnotation[] rawAnnotations) {
     for (GrAnnotation annotation : rawAnnotations) {
-      final PsiElement resolved = annotation.getClassReference().resolve();
-      final GrAnnotation annotationCollector = findAnnotationCollector(resolved);
+      final GrAnnotation annotationCollector = findAnnotationCollector(annotation);
       if (annotationCollector != null) {
         return true;
       }
@@ -164,7 +163,7 @@ public class GrAnnotationCollector {
   }
 
   @Nullable
-  public static GrAnnotation findAnnotationCollector(PsiElement clazz) {
+  public static GrAnnotation findAnnotationCollector(PsiClass clazz) {
     if (clazz instanceof GrTypeDefinition) {
       final GrModifierList modifierList = ((GrTypeDefinition)clazz).getModifierList();
       if (modifierList != null) {
@@ -178,4 +177,18 @@ public class GrAnnotationCollector {
 
     return null;
   }
+
+
+  @Nullable
+  public static GrAnnotation findAnnotationCollector(@NotNull GrAnnotation annotation) {
+    final GrCodeReferenceElement ref = annotation.getClassReference();
+
+    final PsiElement resolved = ref.resolve();
+    if (resolved instanceof PsiClass) {
+      return findAnnotationCollector((PsiClass)resolved);
+    }
+    else {
+      return null;
+    }
+  }
 }
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/aliasAnnotations/GrAnnotationHighlightingTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/aliasAnnotations/GrAnnotationHighlightingTest.groovy
index 91b136bd0f6f..9beb849df765 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/aliasAnnotations/GrAnnotationHighlightingTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/aliasAnnotations/GrAnnotationHighlightingTest.groovy
@@ -81,7 +81,7 @@ import groovy.transform.*
 @AnnotationCollector([EqualsAndHashCode, Immutable])
 @interface Alias {}
 
-@<error descr="'@ToString' not applicable to local variable">Alias</error>(excludes = ['a'])
+@<error descr="'@groovy.transform.EqualsAndHashCode' not applicable to local variable"><error descr="'@groovy.transform.Immutable' not applicable to local variable"><error descr="'@groovy.transform.ToString' not applicable to local variable">Alias</error></error></error>(excludes = ['a'])
 int foo
 ''')
   }
@@ -137,6 +137,66 @@ import groovy.transform.*
 class Foo {
     Integer a, b
 }
+''')
+  }
+
+  public void testAnnotationCollectorInterfaceWithAttrs() {
+    testHighlighting('''\
+@interface Foo {
+  int foo()
+}
+
+
+@groovy.transform.AnnotationCollector
+@Foo
+@interface <error descr="Annotation type annotated with @AnnotationCollector cannot have attributes">A</error> {
+  int bar()
+}
+
+@A(foo = 2)
+class X{}
+''')
+  }
+
+  public void testAnnotationCollectorClass() {
+    testHighlighting('''
+@interface Foo {
+  int foo()
+}
+
+@groovy.transform.AnnotationCollector
+@Foo
+class A {
+  int bar() {}
+}
+
+class B{}
+
+@A(foo = 2)
+@<error descr="'B' is not an annotation">B</error>
+class X {}
+''')
+  }
+
+  void testInapplicableAlias2() {
+    testHighlighting('''\
+import groovy.transform.AnnotationCollector
+import groovy.transform.Immutable
+import groovy.transform.ToString
+
+@AnnotationCollector([Immutable, ToString])
+@interface Alias4 {}
+
+@Immutable
+@ToString
+@AnnotationCollector
+@interface Alias5 {}
+
+@<error descr="'@groovy.transform.Immutable' not applicable to method"><error descr="'@groovy.transform.ToString' not applicable to method">Alias4</error></error>
+def aaa() {}
+
+@<error descr="'@groovy.transform.Immutable' not applicable to method"><error descr="'@groovy.transform.ToString' not applicable to method">Alias5</error></error>
+def bbb() {}
 ''')
   }
 }
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
index bd64b661cac2..e580466e0d0a 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
@@ -1120,43 +1120,4 @@ print(<error descr="Collection literal contains named and expression arguments a
 ''')
   }
 
-  public void testAnnotationCollectorInterfaceWithAttrs() {
-    testHighlighting('''\
-@interface Foo {
-  int foo()
-}
-
-
-@groovy.transform.AnnotationCollector
-@Foo
-@interface <error descr="Annotation type annotated with @AnnotationCollector cannot have attributes">A</error> {
-  int bar()
-}
-
-@A(foo = 2)
-class X{}
-''')
-  }
-
-  public void testAnnotationCollectorClass() {
-    testHighlighting('''
-@interface Foo {
-  int foo()
-}
-
-@groovy.transform.AnnotationCollector
-@Foo
-class A {
-  int bar() {}
-}
-
-class B{}
-
-@A(foo = 2)
-@<error descr="'B' is not an annotation">B</error>
-class X {}
-''')
-
-
-  }
 }
\ No newline at end of file

From c608e62c9a158b22adb2814e194e32564601fa4c Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Sat, 23 Feb 2013 11:21:48 +0400
Subject: [PATCH 079/354] IDEA-100082 Groovy 2.1: Code Completion for aliased
 annotations attributes

---
 .../lang/completion/GroovyCompletionUtil.java | 36 +++++++++++++++----
 .../completion/GroovyCompletionTest.groovy    | 32 +++++++++++++++++
 .../GroovyCompletionTestBase.groovy           |  6 ++--
 3 files changed, 65 insertions(+), 9 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionUtil.java
index 142cc63ad193..bcdc5b3d9142 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -76,6 +76,7 @@ import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeElement;
 import org.jetbrains.plugins.groovy.lang.psi.dataFlow.types.TypeInferenceHelper;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyResolveResultImpl;
 import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
+import org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.modifiers.GrAnnotationCollector;
 import org.jetbrains.plugins.groovy.lang.psi.util.GdkMethodUtil;
 import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
 import org.jetbrains.plugins.groovy.refactoring.GroovyRefactoringUtil;
@@ -573,12 +574,35 @@ public class GroovyCompletionUtil {
     if (anno != null) {
       GrCodeReferenceElement ref = anno.getClassReference();
       PsiElement resolved = ref.resolve();
-      if (resolved instanceof PsiClass && ((PsiClass)resolved).isAnnotationType()) {
-        List<LookupElement> result = new ArrayList<LookupElement>();
-        for (PsiMethod method : ((PsiClass)resolved).getMethods()) {
-          result.addAll(createLookupElements(new GroovyResolveResultImpl(method, true), false, matcher, null));
+
+      if (resolved instanceof PsiClass) {
+        final GrAnnotation annotationCollector = GrAnnotationCollector.findAnnotationCollector((PsiClass)resolved);
+
+        if (annotationCollector != null) {
+          final ArrayList<GrAnnotation> annotations = ContainerUtil.newArrayList();
+          GrAnnotationCollector.collectAnnotations(annotations, anno, annotationCollector);
+
+          Set<String> usedNames = ContainerUtil.newHashSet();
+          List<LookupElement> result = new ArrayList<LookupElement>();
+          for (GrAnnotation annotation : annotations) {
+            final PsiElement resolvedAliased = annotation.getClassReference().resolve();
+            if (resolvedAliased instanceof PsiClass && ((PsiClass)resolvedAliased).isAnnotationType()) {
+              for (PsiMethod method : ((PsiClass)resolvedAliased).getMethods()) {
+                if (usedNames.add(method.getName())) {
+                  result.addAll(createLookupElements(new GroovyResolveResultImpl(method, true), false, matcher, null));
+                }
+              }
+            }
+          }
+          return result;
+        }
+        else if (((PsiClass)resolved).isAnnotationType()) {
+          List<LookupElement> result = new ArrayList<LookupElement>();
+          for (PsiMethod method : ((PsiClass)resolved).getMethods()) {
+            result.addAll(createLookupElements(new GroovyResolveResultImpl(method, true), false, matcher, null));
+          }
+          return result;
         }
-        return result;
       }
     }
 
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
index 11d29c2081e8..a8261d7b5d92 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy
@@ -1672,6 +1672,38 @@ void foo() {
 }""")
   }
 
+  public void testAliasAnnotation() {
+    myFixture.addClass '''\
+package groovy.transform;
+
+@java.lang.annotation.Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
+public @interface AnnotationCollector {
+    String processor() default "org.codehaus.groovy.transform.AnnotationCollectorTransform";
+    Class[] value() default {};
+}
+'''
+
+    doVariantableTest('''\
+import groovy.transform.AnnotationCollector
+
+@interface Bar {
+    int xxx()
+}
+
+@interface Foo {
+    int yyy()
+}
+
+@Foo @Bar
+@AnnotationCollector()
+@interface Alias1 {}
+
+@Alias1(<caret>)
+class Baz {}''', '', CompletionType.BASIC, CompletionResult.contain, 'xxx', 'yyy')
+  }
+
   public void "test honor statistics"() {
     ((StatisticsManagerImpl)StatisticsManager.instance).enableStatistics(testRootDisposable)
 
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTestBase.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTestBase.groovy
index da7c2fb8c1cb..cbef31b9025b 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTestBase.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTestBase.groovy
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -72,14 +72,14 @@ abstract public class GroovyCompletionTestBase extends LightCodeInsightFixtureTe
     final actual = myFixture.lookupElementStrings
     switch (testType) {
       case CompletionResult.contain:
-        assertTrue(actual.containsAll(variants))
+        assertTrue(myFixture.lookupElementStrings as String, actual.containsAll(variants))
         break
       case CompletionResult.equal:
         assertOrderedEquals(actual, variants)
         break
       case CompletionResult.notContain:
         variants.each {
-          assertFalse(actual.contains(it))
+          assertFalse(myFixture.lookupElementStrings as String, actual.contains(it))
         }
     }
   }

From 1011c530623af481944819d29c90f163e0f006c3 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Sat, 23 Feb 2013 10:34:47 +0100
Subject: [PATCH 080/354] IDEA-101658 junit.framework.TestCase#assertNotNull
 isn't used by static analysis

---
 .../intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
index 1107a2e8f955..4b99a0540ebb 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ControlFlowAnalyzer.java
@@ -1305,7 +1305,8 @@ class ControlFlowAnalyzer extends JavaElementVisitor {
             return true;
           }
         }
-        else if ("junit.framework.Assert".equals(className) || "org.junit.Assert".equals(className) || "org.testng.Assert".equals(className)) {
+        else if ("junit.framework.Assert".equals(className) || "org.junit.Assert".equals(className) ||
+                 "junit.framework.TestCase".equals(className) || "org.testng.Assert".equals(className)) {
           boolean testng = "org.testng.Assert".equals(className);
           if ("fail".equals(methodName)) {
             pushParameters(params, false, !testng);

From c7cd56545453b1931feeef3a468cad5ce1021786 Mon Sep 17 00:00:00 2001
From: "Nadya.Zabrodina" <Nadya.Zabrodina@jetbrains.com>
Date: Sat, 23 Feb 2013 17:36:05 +0400
Subject: [PATCH 081/354]  Create HgStatusCommand using appropriate builder
 structure.

 *Change HgStatusCommand constructors call.
 *Fix for IDEA-101722
---
 .../src/org/zmlx/hg4idea/HgVFSListener.java   |   8 +-
 .../zmlx/hg4idea/command/HgStatusCommand.java | 107 ++++++++++--------
 .../hg4idea/provider/HgChangeProvider.java    |   2 +-
 .../provider/commit/HgCheckinEnvironment.java |   6 +-
 .../provider/update/HgRegularUpdater.java     |   6 +-
 .../src/org/zmlx/hg4idea/util/HgUtil.java     |   7 +-
 .../org/zmlx/hg4idea/test/HgUpdateTest.java   |  17 +--
 7 files changed, 71 insertions(+), 82 deletions(-)

diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
index 1f1be2056375..99f3e55e2d16 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
@@ -96,7 +96,9 @@ public class HgVFSListener extends VcsVFSListener {
           final Collection<VirtualFile> files = e.getValue();
           pi.setText(repo.getPresentableUrl());
           try {
-            untrackedFiles.addAll(new HgStatusCommand(myProject).getHgUntrackedFiles(repo, new ArrayList<VirtualFile>(files)));
+            untrackedFiles
+              .addAll(new HgStatusCommand.Builder(false).includeUnknown(true).build(myProject)
+                        .getHgUntrackedFiles(repo, new ArrayList<VirtualFile>(files)));
           }
           catch (final VcsException ex) {
             UIUtil.invokeLaterIfNeeded(new Runnable() {
@@ -144,9 +146,7 @@ public class HgVFSListener extends VcsVFSListener {
         if (myProject != null) {
           Collection<VirtualFile> unversionedAndIgnoredFiles = new ArrayList<VirtualFile>();
           final Map<VirtualFile, Collection<VirtualFile>> sortedSourceFilesByRepos = HgUtil.sortByHgRoots(myProject, copyFromMap.values());
-          HgStatusCommand statusCommand = new HgStatusCommand(myProject);
-          statusCommand.setOnlyUntrackedTrue();
-          statusCommand.setIncludeIgnored(true);
+          HgStatusCommand statusCommand = new HgStatusCommand.Builder(false).includeUnknown(true).includeIgnored(true).build(myProject);
           for (VirtualFile repo : sortedSourceFilesByRepos.keySet()) {
             Set<HgChange> changes = statusCommand.execute(repo);
             for (HgChange change : changes) {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
index 3d377e9155c6..15384dc04e58 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
@@ -39,52 +39,72 @@ public class HgStatusCommand {
 
   private final Project project;
 
-  private boolean includeAdded = true;
-  private boolean includeModified = true;
-  private boolean includeRemoved = true;
-  private boolean includeDeleted = true;
-  private boolean includeUnknown = true;
-  private boolean includeIgnored = true;
-  private boolean includeCopySource = true;
+  private final boolean includeAdded;
+  private final boolean includeModified;
+  private final boolean includeRemoved;
+  private final boolean includeDeleted;
+  private final boolean includeUnknown;
+  private final boolean includeIgnored;
+  private final boolean includeCopySource;
+
   @Nullable private HgRevisionNumber baseRevision;
   @Nullable private HgRevisionNumber targetRevision;
   private HgPlatformFacade myPlatformFacade;
 
-  public HgStatusCommand(Project project) {
-    this(project, ServiceManager.getService(project, HgPlatformFacade.class));
+
+  public static class Builder {
+    private boolean includeAdded;
+    private boolean includeModified;
+    private boolean includeRemoved;
+    private boolean includeDeleted;
+    private boolean includeUnknown;
+    private boolean includeIgnored;
+    private boolean includeCopySource;
+
+    public Builder(boolean initValue) {
+      includeAdded = initValue;
+      includeModified = initValue;
+      includeRemoved = initValue;
+      includeDeleted = initValue;
+      includeUnknown = initValue;
+      includeIgnored = initValue;
+      includeCopySource = initValue;
+    }
+
+    public Builder includeUnknown(boolean val) {
+      includeUnknown = val;
+      return this;
+    }
+
+    public Builder includeIgnored(boolean val) {
+      includeIgnored = val;
+      return this;
+    }
+
+    public Builder includeCopySource(boolean val) {
+      includeCopySource = val;
+      return this;
+    }
+
+    public HgStatusCommand build(Project project) {
+      return new HgStatusCommand(project, ServiceManager.getService(project, HgPlatformFacade.class), this);
+    }
+
+    public HgStatusCommand build(Project project, HgPlatformFacade facade) {
+      return new HgStatusCommand(project, facade, this);
+    }
   }
 
-  public HgStatusCommand(Project project, HgPlatformFacade facade) {
+  private HgStatusCommand(Project project, HgPlatformFacade facade, Builder builder) {
     this.project = project;
     myPlatformFacade = facade;
-  }
-
-  public void setIncludeAdded(boolean includeAdded) {
-    this.includeAdded = includeAdded;
-  }
-
-  public void setIncludeModified(boolean includeModified) {
-    this.includeModified = includeModified;
-  }
-
-  public void setIncludeRemoved(boolean includeRemoved) {
-    this.includeRemoved = includeRemoved;
-  }
-
-  public void setIncludeDeleted(boolean includeDeleted) {
-    this.includeDeleted = includeDeleted;
-  }
-
-  public void setIncludeUnknown(boolean includeUnknown) {
-    this.includeUnknown = includeUnknown;
-  }
-
-  public void setIncludeIgnored(boolean includeIgnored) {
-    this.includeIgnored = includeIgnored;
-  }
-
-  public void setIncludeCopySource(boolean includeCopySource) {
-    this.includeCopySource = includeCopySource;
+    includeAdded = builder.includeAdded;
+    includeModified = builder.includeModified;
+    includeRemoved = builder.includeRemoved;
+    includeDeleted = builder.includeDeleted;
+    includeUnknown = builder.includeUnknown;
+    includeIgnored = builder.includeIgnored;
+    includeCopySource = builder.includeCopySource;
   }
 
   public void setBaseRevision(@Nullable HgRevisionNumber base) {
@@ -187,20 +207,9 @@ public class HgStatusCommand {
     return changes;
   }
 
-  public void setOnlyUntrackedTrue() {
-    includeAdded = false;
-    includeModified = false;
-    includeRemoved = false;
-    includeDeleted = false;
-    includeCopySource = false;
-    includeIgnored = false;
-    includeUnknown = true;
-  }
-
   @NotNull
   public Collection<VirtualFile> getHgUntrackedFiles(@NotNull VirtualFile repo, @NotNull List<VirtualFile> files) throws VcsException {
     Collection<VirtualFile> untrackedFiles = new HashSet<VirtualFile>();
-    setOnlyUntrackedTrue();
     List<FilePath> filePaths = ObjectsConvertor.vf2fp(files);
     Set<HgChange> change = execute(repo, filePaths);
     for (HgChange hgChange : change) {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgChangeProvider.java b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgChangeProvider.java
index 6969deb9f905..371fc70979b5 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgChangeProvider.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgChangeProvider.java
@@ -83,7 +83,7 @@ public class HgChangeProvider implements ChangeProvider {
       final HgRevisionNumber parentRevision = new HgWorkingCopyRevisionsCommand(myProject).firstParent(repo);
       final Map<HgFile, HgResolveStatusEnum> list = new HgResolveCommand(myProject).getListSynchronously(repo);
 
-      hgChanges.addAll(new HgStatusCommand(myProject).execute(repo, entry.getValue()));
+      hgChanges.addAll(new HgStatusCommand.Builder(true).build(myProject).execute(repo, entry.getValue()));
       sendChanges(builder, hgChanges, list, workingRevision, parentRevision);
     }
     return hgChanges;
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/commit/HgCheckinEnvironment.java b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/commit/HgCheckinEnvironment.java
index dee98d653983..9f04d14e89af 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/commit/HgCheckinEnvironment.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/commit/HgCheckinEnvironment.java
@@ -38,8 +38,6 @@ import org.zmlx.hg4idea.command.*;
 import org.zmlx.hg4idea.execution.HgCommandException;
 
 import java.util.*;
-import java.util.HashMap;
-import java.util.HashSet;
 
 public class HgCheckinEnvironment implements CheckinEnvironment {
 
@@ -136,10 +134,8 @@ public class HgCheckinEnvironment implements CheckinEnvironment {
   private Set<HgFile> getChangedFilesNotInCommit(VirtualFile repo, Set<HgFile> selectedFiles) {
     List<HgRevisionNumber> parents = new HgWorkingCopyRevisionsCommand(myProject).parents(repo);
 
-    HgStatusCommand statusCommand = new HgStatusCommand(myProject);
+    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).includeUnknown(false).includeIgnored(false).build(myProject);
     statusCommand.setBaseRevision(parents.get(0));
-    statusCommand.setIncludeUnknown(false);
-    statusCommand.setIncludeIgnored(false);
     Set<HgChange> allChangedFilesInRepo = statusCommand.execute(repo);
 
     Set<HgFile> filesNotIncluded = new HashSet<HgFile>();
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/update/HgRegularUpdater.java b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/update/HgRegularUpdater.java
index 91f06c5f135b..2fdc47e4cadb 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/update/HgRegularUpdater.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/update/HgRegularUpdater.java
@@ -216,9 +216,7 @@ public class HgRegularUpdater implements HgUpdater {
   }
 
   private Set<HgChange> getLocalChanges() {
-    HgStatusCommand statusCommand = new HgStatusCommand(project);
-    statusCommand.setIncludeIgnored(false);
-    statusCommand.setIncludeUnknown(false);
+    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).includeUnknown(false).includeIgnored(false).build(project);
     return statusCommand.execute(repository);
   }
 
@@ -266,7 +264,7 @@ public class HgRegularUpdater implements HgUpdater {
     if (parentAfterUpdate.equals(parentBeforeUpdate)) { // nothing to update => returning not to capture local uncommitted changes
       return;
     }
-    HgStatusCommand statusCommand = new HgStatusCommand(project);
+    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).build(project);
     statusCommand.setBaseRevision(parentBeforeUpdate);
     statusCommand.setTargetRevision(parentAfterUpdate);
     Set<HgChange> changes = statusCommand.execute(repo);
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
index ad81451f9dd7..d750f172b3a1 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
@@ -285,10 +285,8 @@ public abstract class HgUtil {
 
 
   public static HgFile getFileNameInTargetRevision(Project project, HgRevisionNumber vcsRevisionNumber, HgFile localHgFile) {
-    HgStatusCommand statCommand = new HgStatusCommand(project);
-    statCommand.setIncludeUnknown(false);
+    HgStatusCommand statCommand = new HgStatusCommand.Builder(true).includeUnknown(false).build(project);
     statCommand.setBaseRevision(vcsRevisionNumber);
-    statCommand.setIncludeCopySource(true);
 
     Set<HgChange> changes = statCommand.execute(localHgFile.getRepo());
 
@@ -402,8 +400,7 @@ public abstract class HgUtil {
                                      @NotNull final FilePath path,
                                      @Nullable final HgFileRevision rev1,
                                      @Nullable final HgFileRevision rev2, HgPlatformFacade facade) {
-    HgStatusCommand statusCommand = new HgStatusCommand(project,facade);
-    statusCommand.setIncludeCopySource(false);
+    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).includeCopySource(false).build(project, facade);
     HgRevisionNumber revNumber1 = null;
     if (rev1 != null) {
       revNumber1 = rev1.getRevisionNumber();
diff --git a/plugins/hg4idea/testSrc/org/zmlx/hg4idea/test/HgUpdateTest.java b/plugins/hg4idea/testSrc/org/zmlx/hg4idea/test/HgUpdateTest.java
index 7ba973ef84ff..4c00183d22d8 100644
--- a/plugins/hg4idea/testSrc/org/zmlx/hg4idea/test/HgUpdateTest.java
+++ b/plugins/hg4idea/testSrc/org/zmlx/hg4idea/test/HgUpdateTest.java
@@ -23,14 +23,7 @@ import org.zmlx.hg4idea.HgChange;
 import org.zmlx.hg4idea.HgFile;
 import org.zmlx.hg4idea.HgFileStatusEnum;
 import org.zmlx.hg4idea.HgRevisionNumber;
-import org.zmlx.hg4idea.command.HgHeadsCommand;
-import org.zmlx.hg4idea.command.HgIncomingCommand;
-import org.zmlx.hg4idea.command.HgParentsCommand;
-import org.zmlx.hg4idea.command.HgPullCommand;
-import org.zmlx.hg4idea.command.HgShowConfigCommand;
-import org.zmlx.hg4idea.command.HgStatusCommand;
-import org.zmlx.hg4idea.command.HgUpdateCommand;
-import org.zmlx.hg4idea.command.HgWorkingCopyRevisionsCommand;
+import org.zmlx.hg4idea.command.*;
 import org.zmlx.hg4idea.provider.update.HgRegularUpdater;
 
 import java.io.File;
@@ -40,11 +33,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertFalse;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
+import static org.testng.Assert.*;
 
 @SuppressWarnings({"ConstantConditions", "ThrowableResultOfMethodCallIgnored"})
 public class HgUpdateTest extends HgCollaborativeTest {
@@ -179,7 +168,7 @@ public class HgUpdateTest extends HgCollaborativeTest {
   }
 
   private void assertIsChanged(HgFileStatusEnum status, String... filepath) {
-    Set<HgChange> localChanges = new HgStatusCommand(myProject).execute(projectRepoVirtualFile);
+    Set<HgChange> localChanges = new HgStatusCommand.Builder(true).build(myProject).execute(projectRepoVirtualFile);
     assertTrue(localChanges.contains(new HgChange(getHgFile(filepath), status)));
   }
 

From 510bb1f79d612e700623ecb2972ea054f4a7cf27 Mon Sep 17 00:00:00 2001
From: "Nadya.Zabrodina" <Nadya.Zabrodina@jetbrains.com>
Date: Sat, 23 Feb 2013 17:51:00 +0400
Subject: [PATCH 082/354] Change checking myProject for null with  if-
 statement to assertion.

---
 .../src/org/zmlx/hg4idea/HgVFSListener.java   | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
index 99f3e55e2d16..ede2c660fd8b 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVFSListener.java
@@ -17,6 +17,7 @@ package org.zmlx.hg4idea;
 
 import com.intellij.execution.ui.ConsoleViewContentType;
 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.Project;
@@ -44,6 +45,7 @@ import java.util.concurrent.atomic.AtomicReference;
 public class HgVFSListener extends VcsVFSListener {
 
   private final VcsDirtyScopeManager dirtyScopeManager;
+  private static final Logger LOG = Logger.getInstance(HgVFSListener.class);
 
   protected HgVFSListener(final Project project, final HgVcs vcs) {
     super(project, vcs);
@@ -143,19 +145,17 @@ public class HgVFSListener extends VcsVFSListener {
         final ArrayList<VirtualFile> adds = new ArrayList<VirtualFile>();
         final HashMap<VirtualFile, VirtualFile> copies = new HashMap<VirtualFile, VirtualFile>(); // from -> to
         //delete unversioned and ignored files from copy source
-        if (myProject != null) {
-          Collection<VirtualFile> unversionedAndIgnoredFiles = new ArrayList<VirtualFile>();
-          final Map<VirtualFile, Collection<VirtualFile>> sortedSourceFilesByRepos = HgUtil.sortByHgRoots(myProject, copyFromMap.values());
-          HgStatusCommand statusCommand = new HgStatusCommand.Builder(false).includeUnknown(true).includeIgnored(true).build(myProject);
-          for (VirtualFile repo : sortedSourceFilesByRepos.keySet()) {
-            Set<HgChange> changes = statusCommand.execute(repo);
-            for (HgChange change : changes) {
-              unversionedAndIgnoredFiles.add(change.afterFile().toFilePath().getVirtualFile());
-            }
+        LOG.assertTrue(myProject != null, "Project is null");
+        Collection<VirtualFile> unversionedAndIgnoredFiles = new ArrayList<VirtualFile>();
+        final Map<VirtualFile, Collection<VirtualFile>> sortedSourceFilesByRepos = HgUtil.sortByHgRoots(myProject, copyFromMap.values());
+        HgStatusCommand statusCommand = new HgStatusCommand.Builder(false).includeUnknown(true).includeIgnored(true).build(myProject);
+        for (VirtualFile repo : sortedSourceFilesByRepos.keySet()) {
+          Set<HgChange> changes = statusCommand.execute(repo);
+          for (HgChange change : changes) {
+            unversionedAndIgnoredFiles.add(change.afterFile().toFilePath().getVirtualFile());
           }
-          copyFromMap.values().removeAll(unversionedAndIgnoredFiles);
         }
-
+        copyFromMap.values().removeAll(unversionedAndIgnoredFiles);
 
         // separate adds from copies
         for (VirtualFile file : addedFiles) {

From 3d9d40af2c7fd998231b050be0a70e84662f5e35 Mon Sep 17 00:00:00 2001
From: "Nadya.Zabrodina" <Nadya.Zabrodina@jetbrains.com>
Date: Sat, 23 Feb 2013 17:52:04 +0400
Subject: [PATCH 083/354] Add annotation @Nullable for target revision argument

---
 .../hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
index 15384dc04e58..6953b74f034b 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
@@ -111,7 +111,7 @@ public class HgStatusCommand {
     baseRevision = base;
   }
 
-  public void setTargetRevision(HgRevisionNumber target) {
+  public void setTargetRevision(@Nullable HgRevisionNumber target) {
     targetRevision = target;
   }
 

From dbbc8bb074dad649dd2fa0272e545841a96ffa87 Mon Sep 17 00:00:00 2001
From: "Nadya.Zabrodina" <Nadya.Zabrodina@jetbrains.com>
Date: Sat, 23 Feb 2013 18:09:30 +0400
Subject: [PATCH 084/354] Add assertion if there are no branches to update or
 to merge with.

---
 plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java   | 5 ++---
 .../hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java    | 5 ++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
index 37c72b6861b7..cadfeec91c74 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
@@ -118,9 +118,8 @@ public class HgMergeDialog extends DialogWrapper {
   }
 
   private void loadBranches(VirtualFile root) {
-    if (branchesForRepos.get(root) != null) {
-      branchSelector.setModel(new DefaultComboBoxModel(branchesForRepos.get(root).toArray()));
-    }
+    assert branchesForRepos.get(root) != null;
+    branchSelector.setModel(new DefaultComboBoxModel(branchesForRepos.get(root).toArray()));
   }
 
   private void loadTags(VirtualFile root) {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
index 4f12354a09f9..ecc5a406b3fd 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
@@ -119,9 +119,8 @@ public class HgUpdateToDialog extends DialogWrapper {
   }
 
   private void loadBranches(VirtualFile root) {
-    if (branchesForRepos.get(root) != null) {
-      branchSelector.setModel(new DefaultComboBoxModel(branchesForRepos.get(root).toArray()));
-    }
+    assert branchesForRepos.get(root) != null;
+    branchSelector.setModel(new DefaultComboBoxModel(branchesForRepos.get(root).toArray()));
   }
 
   private void loadTags(VirtualFile root) {

From 0bb39c65b27b1e3e1e43e5b35a7ef029566dfc53 Mon Sep 17 00:00:00 2001
From: "Nadya.Zabrodina" <Nadya.Zabrodina@jetbrains.com>
Date: Sat, 23 Feb 2013 19:53:03 +0400
Subject: [PATCH 085/354] Refactor HgTagBranchCommand. Handle errors when load
 branches for action dialogs.

*Remove unnecessary usage of Consumers in HgTagBranchCommand method execution.
*Check result of command execution and handle errors.
---
 .../org/zmlx/hg4idea/HgVcsMessages.properties |  1 +
 .../src/org/zmlx/hg4idea/HgPusher.java        | 22 ++++++++--------
 .../zmlx/hg4idea/action/HgUpdateToAction.java | 18 +++----------
 .../hg4idea/command/HgTagBranchCommand.java   | 26 ++++---------------
 .../org/zmlx/hg4idea/ui/HgMergeDialog.java    | 16 +++++-------
 .../org/zmlx/hg4idea/ui/HgUpdateToDialog.java | 16 +++++-------
 .../src/org/zmlx/hg4idea/util/HgUiUtil.java   | 21 ++++++++++-----
 7 files changed, 49 insertions(+), 71 deletions(-)

diff --git a/plugins/hg4idea/resources/org/zmlx/hg4idea/HgVcsMessages.properties b/plugins/hg4idea/resources/org/zmlx/hg4idea/HgVcsMessages.properties
index 375ee39ddd23..308d3279e7c6 100644
--- a/plugins/hg4idea/resources/org/zmlx/hg4idea/HgVcsMessages.properties
+++ b/plugins/hg4idea/resources/org/zmlx/hg4idea/HgVcsMessages.properties
@@ -114,6 +114,7 @@ hg4idea.merge.please-commit=Merged heads, please commit repository \"{0}\"
 hg4idea.error.invalidExecutable=\"{0}\" is not a valid mercurial executable
 hg4idea.integrate.other.head=Other head: {0}
 hg4idea.error.log.command.execution=Error during log command execution
+hg4idea.branches.error.description=Couldn't collect information about branches
 
 hg4idea.dialog.login.password.required=Login and password required
 hg4idea.dialog.login.description=Login to {0}
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPusher.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgPusher.java
index 7d978fc5e59f..04c40795f6d9 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPusher.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/HgPusher.java
@@ -21,7 +21,6 @@ import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vcs.ui.VcsBalloonProblemNotifier;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -36,7 +35,7 @@ import org.zmlx.hg4idea.ui.HgPushDialog;
 import org.zmlx.hg4idea.util.HgErrorUtil;
 import org.zmlx.hg4idea.util.HgUtil;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Matcher;
@@ -66,7 +65,9 @@ public class HgPusher {
         }
         VirtualFile firstRepo = repositories.get(0);
         final List<HgTagBranch> branches = getBranches(myProject, firstRepo);
-
+        if (branches.isEmpty()) {
+          return;
+        }
         final AtomicReference<HgPushCommand> pushCommand = new AtomicReference<HgPushCommand>();
         UIUtil.invokeAndWaitIfNeeded(new Runnable() {
           @Override
@@ -94,14 +95,13 @@ public class HgPusher {
 
   @NotNull
   public static List<HgTagBranch> getBranches(@NotNull Project project, @NotNull VirtualFile root) {
-    final List<HgTagBranch> branchesList = new ArrayList<HgTagBranch>();
-    new HgTagBranchCommand(project, root).listBranches(new Consumer<List<HgTagBranch>>() {
-      @Override
-      public void consume(final List<HgTagBranch> branches) {
-        branchesList.addAll(branches);
-      }
-    });
-    return branchesList;
+    HgCommandResult branchesResult = new HgTagBranchCommand(project, root).collectBranches();
+    if (branchesResult == null) {
+      new HgCommandResultNotifier(project)
+        .notifyError(branchesResult, "Mercurial command failed", HgVcsMessages.message("hg4idea.branches.error.description"));
+      return Collections.emptyList();
+    }
+    return HgTagBranchCommand.parseResult(branchesResult);
   }
 
   private static void push(final Project project, HgPushCommand command) {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/action/HgUpdateToAction.java b/plugins/hg4idea/src/org/zmlx/hg4idea/action/HgUpdateToAction.java
index 83c5e202cd4f..f7951e5b7a28 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/action/HgUpdateToAction.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/action/HgUpdateToAction.java
@@ -53,21 +53,9 @@ public class HgUpdateToAction extends HgAbstractGlobalAction {
     dialog.show();
     if (dialog.isOK()) {
       FileDocumentManager.getInstance().saveAllDocuments();
-      String updateToValue;
-      if (dialog.isBranchSelected() && dialog.getBranch() != null) {
-        updateToValue = dialog.getBranch().getName();
-      }
-      else if (dialog.isTagSelected() && dialog.getTag() != null) {
-        updateToValue = dialog.getTag().getName();
-      }
-      else if (dialog.isRevisionSelected()) {
-        updateToValue = dialog.getRevision();
-      }
-      else {
-        new HgCommandResultNotifier(project).notifyError(null, "Update failed", "Couldn't execute Mercurial command");
-        return;// hg execute command error occurs//
-      }
-
+      String updateToValue = dialog.isBranchSelected()
+                             ? dialog.getBranch().getName()
+                             : dialog.isTagSelected() ? dialog.getTag().getName() : dialog.getRevision();
       new Task.Backgroundable(project, HgVcsMessages.message("action.hg4idea.updateTo.description", updateToValue)) {
 
         @Override
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgTagBranchCommand.java b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgTagBranchCommand.java
index 202428d6adeb..b72897e6afe5 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgTagBranchCommand.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgTagBranchCommand.java
@@ -14,13 +14,11 @@ package org.zmlx.hg4idea.command;
 
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.zmlx.hg4idea.HgRevisionNumber;
 import org.zmlx.hg4idea.execution.HgCommandExecutor;
 import org.zmlx.hg4idea.execution.HgCommandResult;
-import org.zmlx.hg4idea.execution.HgCommandResultHandler;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -57,29 +55,15 @@ public class HgTagBranchCommand {
     return output.get(0).trim();
   }
 
-  public void listBranches(final Consumer<List<HgTagBranch>> branchListConsumer) {
-    new HgCommandExecutor(project).execute(repo, "branches", null, new HgCommandResultHandler() {
-      @Override
-      public void process(@Nullable HgCommandResult result) {
-        if (result != null) {
-          branchListConsumer.consume(tokenize(result));
-        }
-      }
-    });
+  public HgCommandResult collectBranches() {
+    return new HgCommandExecutor(project).executeInCurrentThread(repo, "branches", null);
   }
 
-  public void listTags(final Consumer<List<HgTagBranch>> tagListConsumer) {
-    new HgCommandExecutor(project).execute(repo, "tags", null, new HgCommandResultHandler() {
-      @Override
-      public void process(@Nullable HgCommandResult result) {
-        if (result != null) {
-          tagListConsumer.consume(tokenize(result));
-        }
-      }
-    });
+  public HgCommandResult collectTags() {
+    return new HgCommandExecutor(project).executeInCurrentThread(repo, "tags", null);
   }
 
-  private static List<HgTagBranch> tokenize(HgCommandResult result) {
+  public static List<HgTagBranch> parseResult(HgCommandResult result) {
     List<HgTagBranch> branches = new LinkedList<HgTagBranch>();
     for (final String line : result.getOutputLines()) {
       Matcher matcher = BRANCH_LINE.matcher(line);
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
index cadfeec91c74..e2b2a82678a6 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgMergeDialog.java
@@ -16,7 +16,6 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.Nullable;
 import org.zmlx.hg4idea.HgRevisionNumber;
@@ -25,6 +24,7 @@ import org.zmlx.hg4idea.command.HgHeadsCommand;
 import org.zmlx.hg4idea.command.HgTagBranch;
 import org.zmlx.hg4idea.command.HgTagBranchCommand;
 import org.zmlx.hg4idea.command.HgWorkingCopyRevisionsCommand;
+import org.zmlx.hg4idea.execution.HgCommandResult;
 
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
@@ -123,15 +123,13 @@ public class HgMergeDialog extends DialogWrapper {
   }
 
   private void loadTags(VirtualFile root) {
-    new HgTagBranchCommand(project, root).listTags(new Consumer<List<HgTagBranch>>() {
+    HgCommandResult tagsResult = new HgTagBranchCommand(project, root).collectTags();
+    assert tagsResult != null;
+    final List<HgTagBranch> tags = HgTagBranchCommand.parseResult(tagsResult);
+    UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
-      public void consume(final List<HgTagBranch> tags) {
-        UIUtil.invokeAndWaitIfNeeded(new Runnable() {
-          @Override
-          public void run() {
-            tagSelector.setModel(new DefaultComboBoxModel(tags.toArray()));
-          }
-        });
+      public void run() {
+        tagSelector.setModel(new DefaultComboBoxModel(tags.toArray()));
       }
     });
   }
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
index ecc5a406b3fd..e3c03be57a5e 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/ui/HgUpdateToDialog.java
@@ -15,10 +15,10 @@ package org.zmlx.hg4idea.ui;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
 import com.intellij.util.ui.UIUtil;
 import org.zmlx.hg4idea.command.HgTagBranch;
 import org.zmlx.hg4idea.command.HgTagBranchCommand;
+import org.zmlx.hg4idea.execution.HgCommandResult;
 
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
@@ -124,15 +124,13 @@ public class HgUpdateToDialog extends DialogWrapper {
   }
 
   private void loadTags(VirtualFile root) {
-    new HgTagBranchCommand(project, root).listTags(new Consumer<List<HgTagBranch>>() {
+    HgCommandResult tagsResult = new HgTagBranchCommand(project, root).collectTags();
+    assert tagsResult != null;
+    final List<HgTagBranch> tags = HgTagBranchCommand.parseResult(tagsResult);
+    UIUtil.invokeAndWaitIfNeeded(new Runnable() {
       @Override
-      public void consume(final List<HgTagBranch> tags) {
-        UIUtil.invokeAndWaitIfNeeded(new Runnable() {
-          @Override
-          public void run() {
-            tagSelector.setModel(new DefaultComboBoxModel(tags.toArray()));
-          }
-        });
+      public void run() {
+        tagSelector.setModel(new DefaultComboBoxModel(tags.toArray()));
       }
     });
   }
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUiUtil.java b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUiUtil.java
index 703637931334..090a9f46178f 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUiUtil.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUiUtil.java
@@ -22,8 +22,11 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.Consumer;
 import com.intellij.util.containers.HashMap;
 import org.jetbrains.annotations.NotNull;
+import org.zmlx.hg4idea.HgVcsMessages;
+import org.zmlx.hg4idea.action.HgCommandResultNotifier;
 import org.zmlx.hg4idea.command.HgTagBranch;
 import org.zmlx.hg4idea.command.HgTagBranchCommand;
+import org.zmlx.hg4idea.execution.HgCommandResult;
 
 import java.util.Collection;
 import java.util.List;
@@ -42,15 +45,21 @@ public class HgUiUtil {
       @Override
       public void run(@NotNull ProgressIndicator indicator) {
         for (final VirtualFile repo : repos) {
-          new HgTagBranchCommand(project, repo).listBranches(new Consumer<List<HgTagBranch>>() {
-            @Override
-            public void consume(final List<HgTagBranch> branches) {
-              branchesForRepos.put(repo, branches);
-            }
-          });
+          HgCommandResult result = new HgTagBranchCommand(project, repo).collectBranches();
+          if (result == null) {
+            indicator.cancel();
+            return;
+          }
+          branchesForRepos.put(repo, HgTagBranchCommand.parseResult(result));
         }
       }
 
+      @Override
+      public void onCancel() {
+        new HgCommandResultNotifier(project)
+          .notifyError(null, "Mercurial command failed", HgVcsMessages.message("hg4idea.branches.error.description"));
+      }
+
       @Override
       public void onSuccess() {
         successHandler.consume(branchesForRepos);

From fc159dbdf3744e78dab213d41d3319ab09cfe233 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Sun, 24 Feb 2013 14:11:07 +0100
Subject: [PATCH 086/354] new bg for darcula

---
 platform/icons/src/frame_background_dark.png | Bin 66239 -> 124330 bytes
 platform/icons/src/idea_logo_background.png  | Bin 17517 -> 14269 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/platform/icons/src/frame_background_dark.png b/platform/icons/src/frame_background_dark.png
index 71b25f083ca62f18838048b0a42c45e64749f964..a4005940652f3c43f69a7f2ffefff560f6790c94 100644
GIT binary patch
literal 124330
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

literal 66239
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
ViHm(W$5j9T002ovPDHLkV1n=j3z7f;

diff --git a/platform/icons/src/idea_logo_background.png b/platform/icons/src/idea_logo_background.png
index fde50bdd1ac743c24d23f8ae8450eee41cbe6563..86352ccfbd15f40fe919c6c1bfe8ba11217a42ad 100644
GIT binary patch
literal 14269
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

literal 17517
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%0DpXoiZb@UCnoat=#LIGKpY(7n!MQ-D)sie8EMKT
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


From 2ff41bcda2abbdbc455f6ebcd7d363730eab2ed4 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Sun, 24 Feb 2013 14:22:50 +0100
Subject: [PATCH 087/354] new bg for darcula

---
 platform/icons/src/frame_background_dark.png | Bin 124330 -> 66239 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/platform/icons/src/frame_background_dark.png b/platform/icons/src/frame_background_dark.png
index a4005940652f3c43f69a7f2ffefff560f6790c94..71b25f083ca62f18838048b0a42c45e64749f964 100644
GIT binary patch
literal 66239
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
ViHm(W$5j9T002ovPDHLkV1n=j3z7f;

literal 124330
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


From 2a0194e5fac3bb925b76e19c6ce9813967d17bc9 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Sun, 24 Feb 2013 14:27:20 +0100
Subject: [PATCH 088/354] let it be Reveal log on all platforms

---
 .../src/com/intellij/ide/actions/ShowLogAction.java            | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java b/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
index d68063ead8aa..02c2526c3344 100644
--- a/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
+++ b/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
@@ -40,10 +40,11 @@ public class ShowLogAction extends AnAction implements DumbAware {
     Presentation presentation = e.getPresentation();
     presentation.setVisible(ShowFilePathAction.isSupported());
     presentation.setText(getActionName());
+    presentation.setDescription("Show Log in file manager");
   }
 
   @NotNull
   public static String getActionName() {
-    return SystemInfo.isMac ? "Reveal Log in Finder" : "Show Log in " + ShowFilePathAction.getFileManagerName();
+    return SystemInfo.isMac ? "Reveal Log in Finder" : "Reveal Log in " + ShowFilePathAction.getFileManagerName();
   }
 }

From 57b4f3b6fdd9601a5722e0a2ac1de763ef05380a Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Sun, 24 Feb 2013 18:58:51 +0100
Subject: [PATCH 089/354] onSearchFieldUpdated should be called on popup open
 as well

---
 .../platform-impl/src/com/intellij/ui/SpeedSearchBase.java    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java b/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java
index e5da6c269228..4c858db93cd8 100644
--- a/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java
+++ b/platform/platform-impl/src/com/intellij/ui/SpeedSearchBase.java
@@ -373,6 +373,7 @@ public abstract class SpeedSearchBase<Comp extends JComponent> extends SpeedSear
       add(searchLabel, BorderLayout.WEST);
       add(mySearchField, BorderLayout.EAST);
       Object element = findElement(mySearchField.getText());
+      onSearchFieldUpdated(initialString);
       updateSelection(element);
     }
 
@@ -436,7 +437,8 @@ public abstract class SpeedSearchBase<Comp extends JComponent> extends SpeedSear
     }
   }
 
-  protected void onSearchFieldUpdated(String s) {}
+  protected void onSearchFieldUpdated(String pattern) {
+  }
 
   private class SearchField extends JTextField {
     SearchField() {

From 4d193ae5b0f076d907cb4ac3b29784c880528fcf Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Sun, 24 Feb 2013 20:31:21 +0100
Subject: [PATCH 090/354] IDEA-101755 Indent lines and tear line are too bright

---
 colorSchemes/src/colorSchemes/Darcula.xml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 9d5d944c35ca..b6556d6be8a7 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -26,7 +26,7 @@
     <option name="FILESTATUS_changelistConflict" value="d5756c" />
     <option name="FILESTATUS_modifiedOutside" value="6897bb" />
     <option name="GUTTER_BACKGROUND" value="313335" />
-    <option name="INDENT_GUIDE" value="4d4d4d" />
+    <option name="INDENT_GUIDE" value="373737" />
     <option name="LINE_NUMBERS_COLOR" value="888888" />
     <option name="METHOD_SEPARATORS_COLOR" value="4d4d4d" />
     <option name="MODIFIED_LINES_COLOR" value="7180" />
@@ -35,10 +35,11 @@
     <option name="RECURSIVE_CALL_ATTRIBUTES" value="574300" />
     <option name="REMOTE_HOST_MAPPED_BACKGROUND_KEY" value="164716" />
     <option name="RIGHT_MARGIN_COLOR" value="4d4d4d" />
+    <option name="SELECTED_INDENT_GUIDE" value="505050" />
     <option name="SELECTED_TEARLINE_COLOR" value="ffffff" />
     <option name="SELECTION_BACKGROUND" value="214283" />
     <option name="SELECTION_FOREGROUND" value="" />
-    <option name="TEARLINE_COLOR" value="909090" />
+    <option name="TEARLINE_COLOR" value="555555" />
     <option name="WHITESPACES" value="404040" />
   </colors>
   <attributes>

From 8ac85d658d15c81478afe66ea6cbe331ce5edac6 Mon Sep 17 00:00:00 2001
From: Vladimir Krivosheev <vladimir.krivosheev@jetbrains.com>
Date: Sun, 24 Feb 2013 23:12:10 +0400
Subject: [PATCH 091/354] fix urls test (windows specific)

---
 .../src/com/intellij/openapi/vfs/VfsUtil.java          | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java b/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
index a790520b165a..531eb4e34bd9 100644
--- a/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
+++ b/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
@@ -501,16 +501,16 @@ public class VfsUtil extends VfsUtilCore {
     }
     else if (SystemInfoRt.isWindows && url.regionMatches(0, LocalFileSystem.PROTOCOL_PREFIX, 0, LocalFileSystem.PROTOCOL_PREFIX.length())) {
       // file:///C:/test/file.js -> file://C:/test/file.js
-      for (int i = index + 3; i < url.length(); i++) {
+      for (int i = index + 4; i < url.length(); i++) {
         char c = url.charAt(i);
         if (c == '/') {
-          return url;
-        }
-        else if (c == ':') {
           break;
         }
+        else if (c == ':') {
+          return LocalFileSystem.PROTOCOL_PREFIX + url.substring(index + 4);
+        }
       }
-      return LocalFileSystem.PROTOCOL_PREFIX + url.substring(index + 3);
+      return url;
     }
     return url;
   }

From 72f2e427ddf5f623d97499478be0413edd7a4b17 Mon Sep 17 00:00:00 2001
From: Vladimir Krivosheev <vladimir.krivosheev@jetbrains.com>
Date: Sun, 24 Feb 2013 23:53:45 +0400
Subject: [PATCH 092/354] fix urls test (windows specific)

---
 platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java b/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
index 531eb4e34bd9..e4100a58f23e 100644
--- a/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
+++ b/platform/platform-api/src/com/intellij/openapi/vfs/VfsUtil.java
@@ -499,7 +499,7 @@ public class VfsUtil extends VfsUtilCore {
         return prefix + ":///" + suffix;
       }
     }
-    else if (SystemInfoRt.isWindows && url.regionMatches(0, LocalFileSystem.PROTOCOL_PREFIX, 0, LocalFileSystem.PROTOCOL_PREFIX.length())) {
+    else if (url.charAt(index + 3) == '/' && SystemInfoRt.isWindows && url.regionMatches(0, LocalFileSystem.PROTOCOL_PREFIX, 0, LocalFileSystem.PROTOCOL_PREFIX.length())) {
       // file:///C:/test/file.js -> file://C:/test/file.js
       for (int i = index + 4; i < url.length(); i++) {
         char c = url.charAt(i);

From b1f6043cc81ac783a2746203f88623b9729aa88e Mon Sep 17 00:00:00 2001
From: "kirill.safonov" <kirill.safonov@jetbrains.com>
Date: Mon, 25 Feb 2013 10:30:09 +0400
Subject: [PATCH 093/354] JS, AS: don't implicitly consider references in
 strings as code references (IDEA-89329, WEB-833 & co)

---
 .../refactoring/rename/RenamePsiElementProcessor.java      | 5 +++++
 .../src/com/intellij/refactoring/rename/RenameUtil.java    | 2 +-
 .../intellij/refactoring/rename/inplace/RenameChooser.java | 7 +++++++
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/refactoring/rename/RenamePsiElementProcessor.java b/platform/lang-impl/src/com/intellij/refactoring/rename/RenamePsiElementProcessor.java
index 3a095feff05a..736f482259da 100644
--- a/platform/lang-impl/src/com/intellij/refactoring/rename/RenamePsiElementProcessor.java
+++ b/platform/lang-impl/src/com/intellij/refactoring/rename/RenamePsiElementProcessor.java
@@ -59,6 +59,11 @@ public abstract class RenamePsiElementProcessor {
     RenameUtil.doRenameGenericNamedElement(element, newName, usages, listener);
   }
 
+  @NotNull
+  public Collection<PsiReference> findReferences(final PsiElement element, boolean searchInCommentsAndStrings) {
+    return findReferences(element);
+  }
+
   @NotNull
   public Collection<PsiReference> findReferences(final PsiElement element) {
     return ReferencesSearch.search(element).findAll();
diff --git a/platform/lang-impl/src/com/intellij/refactoring/rename/RenameUtil.java b/platform/lang-impl/src/com/intellij/refactoring/rename/RenameUtil.java
index c810f88cc359..05acdf4257d2 100644
--- a/platform/lang-impl/src/com/intellij/refactoring/rename/RenameUtil.java
+++ b/platform/lang-impl/src/com/intellij/refactoring/rename/RenameUtil.java
@@ -68,7 +68,7 @@ public class RenameUtil {
     GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject());
     RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(element);
 
-    Collection<PsiReference> refs = processor.findReferences(element);
+    Collection<PsiReference> refs = processor.findReferences(element, searchInStringsAndComments);
     for (final PsiReference ref : refs) {
       if (ref == null) {
         LOG.error("null reference from processor " + processor);
diff --git a/platform/lang-impl/src/com/intellij/refactoring/rename/inplace/RenameChooser.java b/platform/lang-impl/src/com/intellij/refactoring/rename/inplace/RenameChooser.java
index dce7f6da2baa..36aa8673efa1 100644
--- a/platform/lang-impl/src/com/intellij/refactoring/rename/inplace/RenameChooser.java
+++ b/platform/lang-impl/src/com/intellij/refactoring/rename/inplace/RenameChooser.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.refactoring.rename.inplace;
 
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.colors.EditorColors;
 import com.intellij.openapi.editor.colors.EditorColorsManager;
@@ -26,6 +27,7 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
+import com.intellij.refactoring.RefactoringSettings;
 import com.intellij.ui.components.JBList;
 import org.jetbrains.annotations.NonNls;
 
@@ -54,6 +56,11 @@ abstract class RenameChooser {
   
   public void showChooser(final Collection<PsiReference> refs,
                           final Collection<Pair<PsiElement, TextRange>> stringUsages) {
+    if (ApplicationManager.getApplication().isUnitTestMode()) {
+      runRenameTemplate(
+        RefactoringSettings.getInstance().RENAME_SEARCH_IN_COMMENTS_FOR_FILE ? stringUsages : new ArrayList<Pair<PsiElement, TextRange>>());
+      return;
+    }
 
     final DefaultListModel model = new DefaultListModel();
     model.addElement(CODE_OCCURRENCES);

From a6bad4822f861788b361b4757504ac9f8c302b52 Mon Sep 17 00:00:00 2001
From: Fedor Korotkov <fedor.korotkov@jetbrains.com>
Date: Mon, 25 Feb 2013 11:19:26 +0400
Subject: [PATCH 094/354] WEB-384 Microdata attributes support

---
 .../src/META-INF/XmlPlugin.xml                |   1 +
 .../impl/quickfix/FetchExtResourceAction.java |  39 ++--
 ...MicrodataAttributeDescriptorsProvider.java | 138 +++++++++++
 .../providers/MicrodataReferenceProvider.java |  37 +++
 .../html/impl/util/MicrodataUtil.java         | 217 ++++++++++++++++++
 .../xml/util/XmlReferenceContributor.java     |   9 +
 .../html/MicrodataCompletionTest.java         | 154 +++++++++++++
 xml/tests/testData/microdata/Address.html     | 105 +++++++++
 xml/tests/testData/microdata/Person.html      | 163 +++++++++++++
 9 files changed, 848 insertions(+), 15 deletions(-)
 create mode 100644 xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
 create mode 100644 xml/impl/src/com/intellij/html/impl/providers/MicrodataReferenceProvider.java
 create mode 100644 xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
 create mode 100644 xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
 create mode 100644 xml/tests/testData/microdata/Address.html
 create mode 100644 xml/tests/testData/microdata/Person.html

diff --git a/platform/platform-resources/src/META-INF/XmlPlugin.xml b/platform/platform-resources/src/META-INF/XmlPlugin.xml
index 6eed810dd60a..9aeae4eb1c56 100644
--- a/platform/platform-resources/src/META-INF/XmlPlugin.xml
+++ b/platform/platform-resources/src/META-INF/XmlPlugin.xml
@@ -454,6 +454,7 @@
     <renameInputValidator implementation="com.intellij.lang.xml.XmlAttributeValueRenameValidator"/>
 
     <xml.attributeDescriptorsProvider implementation="com.intellij.html.impl.Html5CustomAttributeDescriptorsProvider"/>
+    <xml.attributeDescriptorsProvider implementation="com.intellij.html.impl.MicrodataAttributeDescriptorsProvider"/>
 
     <breadcrumbsPresentationProvider implementation="com.intellij.codeInsight.daemon.impl.tagTreeHighlighting.XmlTagTreeBreadcrumbsPresentationProvider"/>
     <daemon.changeLocalityDetector implementation="com.intellij.xml.XmlChangeLocalityDetector"/>
diff --git a/xml/impl/src/com/intellij/codeInsight/daemon/impl/quickfix/FetchExtResourceAction.java b/xml/impl/src/com/intellij/codeInsight/daemon/impl/quickfix/FetchExtResourceAction.java
index 9d114d27aad0..916f8f7eb730 100644
--- a/xml/impl/src/com/intellij/codeInsight/daemon/impl/quickfix/FetchExtResourceAction.java
+++ b/xml/impl/src/com/intellij/codeInsight/daemon/impl/quickfix/FetchExtResourceAction.java
@@ -314,7 +314,7 @@ public class FetchExtResourceAction extends BaseExtResourceAction implements Wat
   }
 
   @Nullable
-  private static String fetchOneFile(final ProgressIndicator indicator,
+  private String fetchOneFile(final ProgressIndicator indicator,
                                      final String resourceUrl,
                                      final Project project,
                                      String extResourcesPath,
@@ -330,18 +330,7 @@ public class FetchExtResourceAction extends BaseExtResourceAction implements Wat
     FetchResult result = fetchData(project, resourceUrl, indicator);
     if (result == null) return null;
 
-    if (!ApplicationManager.getApplication().isUnitTestMode() &&
-        result.contentType != null &&
-        result.contentType.contains(HTML_MIME) &&
-        new String(result.bytes).contains("<html")) {
-      ApplicationManager.getApplication().invokeLater(new Runnable() {
-        public void run() {
-          Messages.showMessageDialog(project,
-                                     XmlBundle.message("invalid.url.no.xml.file.at.location", resourceUrl),
-                                     XmlBundle.message("invalid.url.title"),
-                                     Messages.getErrorIcon());
-        }
-      }, indicator.getModalityState());
+    if(!resultIsValid(project, indicator, resourceUrl, result)) {
       return null;
     }
 
@@ -366,7 +355,9 @@ public class FetchExtResourceAction extends BaseExtResourceAction implements Wat
     if (lastDoPosInResourceUrl == -1 ||
         FileTypeManager.getInstance().getFileTypeByExtension(resourceUrl.substring(lastDoPosInResourceUrl + 1)) == FileTypes.UNKNOWN) {
       // remote url does not contain file with extension
-      resPath += "." + StdFileTypes.XML.getDefaultExtension();
+      final String extension =
+        result.contentType.contains(HTML_MIME) ? StdFileTypes.HTML.getDefaultExtension() : StdFileTypes.XML.getDefaultExtension();
+      resPath += "." + extension;
     }
 
     File res = new File(resPath);
@@ -381,6 +372,24 @@ public class FetchExtResourceAction extends BaseExtResourceAction implements Wat
     return resPath;
   }
 
+  protected boolean resultIsValid(final Project project, ProgressIndicator indicator, final String resourceUrl, FetchResult result) {
+    if (!ApplicationManager.getApplication().isUnitTestMode() &&
+        result.contentType != null &&
+        result.contentType.contains(HTML_MIME) &&
+        new String(result.bytes).contains("<html")) {
+      ApplicationManager.getApplication().invokeLater(new Runnable() {
+        public void run() {
+          Messages.showMessageDialog(project,
+                                     XmlBundle.message("invalid.url.no.xml.file.at.location", resourceUrl),
+                                     XmlBundle.message("invalid.url.title"),
+                                     Messages.getErrorIcon());
+        }
+      }, indicator.getModalityState());
+      return false;
+    }
+    return true;
+  }
+
   private static List<String> extractEmbeddedFileReferences(XmlFile file, XmlFile context) {
     final List<String> result = new LinkedList<String>();
     if (context != null) {
@@ -474,7 +483,7 @@ public class FetchExtResourceAction extends BaseExtResourceAction implements Wat
     });
   }
 
-  static class FetchResult {
+  protected static class FetchResult {
     byte[] bytes;
     String contentType;
   }
diff --git a/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
new file mode 100644
index 000000000000..2279ca785aee
--- /dev/null
+++ b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2000-2013 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.html.impl;
+
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.xml.XmlAttribute;
+import com.intellij.psi.xml.XmlAttributeValue;
+import com.intellij.psi.xml.XmlTag;
+import com.intellij.util.ArrayUtil;
+import com.intellij.xml.XmlAttributeDescriptor;
+import com.intellij.xml.XmlAttributeDescriptorsProvider;
+import com.intellij.xml.impl.schema.AnyXmlAttributeDescriptor;
+import com.intellij.xml.util.HtmlUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.intellij.html.impl.util.MicrodataUtil.*;
+
+/**
+ * @author: Fedor.Korotkov
+ */
+public class MicrodataAttributeDescriptorsProvider implements XmlAttributeDescriptorsProvider {
+  @Override
+  public XmlAttributeDescriptor[] getAttributeDescriptors(XmlTag context) {
+    if (!HtmlUtil.isHtml5Context(context)) {
+      return XmlAttributeDescriptor.EMPTY;
+    }
+    final String tagName = context.getName();
+    List<XmlAttributeDescriptor> result = new ArrayList<XmlAttributeDescriptor>();
+    final boolean goodContextForProps =
+      "div".equalsIgnoreCase(tagName) || "span".equalsIgnoreCase(tagName) || "a".equalsIgnoreCase(tagName);
+    if (goodContextForProps && hasScopeTag(context)) {
+      result.add(new MicrodataPropertyAttributeDescriptor(context));
+    }
+    if (context.getAttribute(ITEM_SCOPE) == null) {
+      result.add(new AnyXmlAttributeDescriptor(ITEM_SCOPE));
+    }
+    else {
+      result.add(new XmlAttributeDescriptorWithEmptyDefaultValue(ITEM_ID));
+      result.add(new XmlAttributeDescriptorWithEmptyDefaultValue(ITEM_TYPE));
+      result.add(new XmlAttributeDescriptorWithEmptyDefaultValue(ITEM_REF));
+    }
+    return result.toArray(new XmlAttributeDescriptor[result.size()]);
+  }
+
+  @Nullable
+  @Override
+  public XmlAttributeDescriptor getAttributeDescriptor(String attributeName, XmlTag context) {
+    if (!HtmlUtil.isHtml5Context(context)) {
+      return null;
+    }
+    if (ITEM_SCOPE.equalsIgnoreCase(attributeName)) {
+      return new AnyXmlAttributeDescriptor(attributeName);
+    }
+    if (context.getAttribute(ITEM_SCOPE) != null &&
+        (ITEM_TYPE.equalsIgnoreCase(attributeName) || ITEM_ID.equalsIgnoreCase(attributeName) || ITEM_REF.equalsIgnoreCase(attributeName))) {
+      return new XmlAttributeDescriptorWithEmptyDefaultValue(attributeName);
+    }
+    if (ITEM_PROP.equalsIgnoreCase(attributeName) && hasScopeTag(context)) {
+      return new MicrodataPropertyAttributeDescriptor(context);
+    }
+    return null;
+  }
+
+  private static class XmlAttributeDescriptorWithEmptyDefaultValue extends AnyXmlAttributeDescriptor {
+    public XmlAttributeDescriptorWithEmptyDefaultValue(String name) {
+      super(name);
+    }
+
+    @Override
+    public String getDefaultValue() {
+      return "";
+    }
+  }
+
+  private static class MicrodataPropertyAttributeDescriptor extends AnyXmlAttributeDescriptor {
+
+    private final XmlTag myContext;
+
+    public MicrodataPropertyAttributeDescriptor(XmlTag context) {
+      super(ITEM_PROP);
+      myContext = context;
+    }
+
+    @Override
+    public String getDefaultValue() {
+      return "";
+    }
+
+    @Override
+    public boolean isEnumerated() {
+      final String[] enumeratedValues = getEnumeratedValues();
+      return enumeratedValues == null ? super.isEnumerated() : enumeratedValues.length > 0;
+    }
+
+    @Override
+    public String[] getEnumeratedValues() {
+      final XmlTag scopeParent = findScopeTag(myContext);
+      return scopeParent != null ? findProperties(scopeParent) : super.getEnumeratedValues();
+    }
+
+    private static String[] findProperties(@NotNull XmlTag tag) {
+      final XmlAttribute typeAttribute = tag.getAttribute(ITEM_TYPE);
+      if (typeAttribute != null) {
+        final XmlAttributeValue valueElement = typeAttribute.getValueElement();
+        final PsiReference[] references = valueElement != null ? valueElement.getReferences() : PsiReference.EMPTY_ARRAY;
+        List<String> result = new ArrayList<String>();
+        for (PsiReference reference : references) {
+          final PsiElement target = reference != null ? reference.resolve() : null;
+          if (target instanceof PsiFile) {
+            result.addAll(extractProperties((PsiFile)target, StringUtil.stripQuotesAroundValue(reference.getCanonicalText())));
+          }
+        }
+        return ArrayUtil.toStringArray(result);
+      }
+      return ArrayUtil.EMPTY_STRING_ARRAY;
+    }
+  }
+}
diff --git a/xml/impl/src/com/intellij/html/impl/providers/MicrodataReferenceProvider.java b/xml/impl/src/com/intellij/html/impl/providers/MicrodataReferenceProvider.java
new file mode 100644
index 000000000000..27fd3d2286b3
--- /dev/null
+++ b/xml/impl/src/com/intellij/html/impl/providers/MicrodataReferenceProvider.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2000-2013 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.html.impl.providers;
+
+import com.intellij.html.impl.util.MicrodataUtil;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.PsiReferenceProvider;
+import com.intellij.psi.xml.XmlAttributeValue;
+import com.intellij.util.ProcessingContext;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author: Fedor.Korotkov
+ */
+public class MicrodataReferenceProvider extends PsiReferenceProvider {
+  @NotNull
+  @Override
+  public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext context) {
+    return element instanceof XmlAttributeValue ?
+           MicrodataUtil.getUrlReferencesForAttributeValue((XmlAttributeValue)element) :
+           PsiReference.EMPTY_ARRAY;
+  }
+}
diff --git a/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
new file mode 100644
index 000000000000..9d91f3d69def
--- /dev/null
+++ b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2000-2013 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.html.impl.util;
+
+import com.intellij.codeInsight.daemon.impl.HighlightInfo;
+import com.intellij.codeInsight.daemon.impl.quickfix.FetchExtResourceAction;
+import com.intellij.codeInsight.daemon.impl.quickfix.IgnoreExtResourceAction;
+import com.intellij.codeInsight.daemon.impl.quickfix.ManuallySetupExtResourceAction;
+import com.intellij.codeInsight.daemon.impl.quickfix.QuickFixAction;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.Key;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.XmlRecursiveElementVisitor;
+import com.intellij.psi.impl.source.resolve.reference.impl.providers.URIReferenceProvider;
+import com.intellij.psi.impl.source.resolve.reference.impl.providers.URLReference;
+import com.intellij.psi.xml.XmlAttribute;
+import com.intellij.psi.xml.XmlAttributeValue;
+import com.intellij.psi.xml.XmlFile;
+import com.intellij.psi.xml.XmlTag;
+import com.intellij.util.PairFunction;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.text.StringTokenizer;
+import gnu.trove.THashSet;
+import org.jetbrains.annotations.Nls;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author: Fedor.Korotkov
+ */
+public class MicrodataUtil {
+  public static final Key<List<String>> ITEM_PROP_KEYS = Key.create("microdata.prop");
+  public static final String ITEM_REF = "itemref";
+  public static final String ITEM_SCOPE = "itemscope";
+  public static final String ITEM_TYPE = "itemtype";
+  public static final String ITEM_PROP = "itemprop";
+  public static final String ITEM_ID = "itemid";
+
+  @NonNls private static final String HTTP = "http://";
+  @NonNls private static final String HTTPS = "https://";
+
+  public static boolean hasScopeTag(@Nullable XmlTag tag) {
+    return findScopeTag(tag) != null;
+  }
+
+  @Nullable
+  public static XmlTag findScopeTag(@Nullable XmlTag tag) {
+    while (tag != null) {
+      if (tag.getAttribute(ITEM_SCOPE) != null) return tag;
+      XmlTag scopeTag = findInRefsById(tag);
+      if (scopeTag != null) return scopeTag;
+      tag = tag.getParentTag();
+    }
+    return null;
+  }
+
+  @Nullable
+  private static XmlTag findInRefsById(XmlTag tag) {
+    XmlAttribute idAttr = tag.getAttribute("id");
+    final XmlAttributeValue idValue = idAttr != null ? idAttr.getValueElement() : null;
+    if (idValue == null) {
+      return null;
+    }
+    final String idToFind = StringUtil.stripQuotesAroundValue(idValue.getText());
+    XmlTag parentTag = tag.getParentTag();
+    while (parentTag != null) {
+      XmlTag scopeTag = ContainerUtil.find(parentTag.getSubTags(), new Condition<XmlTag>() {
+        @Override
+        public boolean value(XmlTag tag) {
+          String refValue = tag.getAttributeValue(ITEM_REF);
+          return refValue != null && refValue.contains(idToFind);
+        }
+      });
+      if (scopeTag != null) {
+        return scopeTag;
+      }
+      parentTag = parentTag.getParentTag();
+    }
+    return null;
+  }
+
+  public static List<String> extractProperties(PsiFile file, String type) {
+    final VirtualFile virtualFile = file.getVirtualFile();
+    List<String> result = virtualFile != null ? virtualFile.getUserData(ITEM_PROP_KEYS) : null;
+    if (virtualFile != null && result == null) {
+      result = collectNames(file, type);
+      virtualFile.putUserData(ITEM_PROP_KEYS, result);
+    }
+    return result;
+  }
+
+  private static List<String> collectNames(PsiFile file, String type) {
+    if (file instanceof XmlFile) {
+      final CollectNamesVisitor collectNamesVisitor = new CollectNamesVisitor(type);
+      file.accept(collectNamesVisitor);
+      return collectNamesVisitor.getValues();
+    }
+    return Collections.emptyList();
+  }
+
+  public static PsiReference[] getUrlReferencesForAttributeValue(final XmlAttributeValue element) {
+    return getReferencesForAttributeValue(element, new PairFunction<String, Integer, PsiReference>() {
+      @Nullable
+      @Override
+      public PsiReference fun(String token, Integer offset) {
+        if (isUrl(token)) {
+          final TextRange range = TextRange.from(offset, token.length());
+          final URLReference urlReference = new URLReference(element, range, true);
+          return new URIReferenceProvider.DependentNSReference(element, range, urlReference) {
+            @Override
+            public void registerQuickfix(HighlightInfo info, PsiReference reference) {
+              QuickFixAction.registerQuickFixAction(info, new FetchMicrodataResourceAction());
+              QuickFixAction.registerQuickFixAction(info, new ManuallySetupExtResourceAction());
+              QuickFixAction.registerQuickFixAction(info, new IgnoreExtResourceAction());
+            }
+          };
+        }
+        return null;
+      }
+    });
+  }
+
+  public static PsiReference[] getReferencesForAttributeValue(XmlAttributeValue element,
+                                                              PairFunction<String, Integer, PsiReference> refFun) {
+    String text = element.getText();
+    String urls = StringUtil.stripQuotesAroundValue(text);
+    StringTokenizer tokenizer = new StringTokenizer(urls);
+    List<PsiReference> result = new ArrayList<PsiReference>();
+    while (tokenizer.hasMoreTokens()) {
+      String token = tokenizer.nextToken();
+      int index = text.indexOf(token);
+      PsiReference ref = refFun.fun(token, index);
+      if (ref != null) {
+        result.add(ref);
+      }
+    }
+    return result.toArray(new PsiReference[result.size()]);
+  }
+
+  private static boolean isUrl(String url) {
+    return url.startsWith(HTTP) || url.startsWith(HTTPS);
+  }
+
+  @Nullable
+  public static String getStripedAttributeValue(@Nullable XmlTag tag, @Nls String attributeName) {
+    String value = tag != null ? tag.getAttributeValue(attributeName) : null;
+    return value != null ? StringUtil.stripQuotesAroundValue(value) : null;
+  }
+
+  private static class CollectNamesVisitor extends XmlRecursiveElementVisitor {
+
+    private final String myType;
+    private boolean myCollecting = false;
+    private final Set<String> myValues = new THashSet<String>();
+
+    public CollectNamesVisitor(String type) {
+      myType = type;
+    }
+
+    @Override
+    public void visitXmlTag(XmlTag tag) {
+      String value = getStripedAttributeValue(tag, ITEM_ID);
+      final boolean isTypeTag = myType.equalsIgnoreCase(value);
+      if (isTypeTag) {
+        myCollecting = true;
+      }
+
+      if (myCollecting && "name".equalsIgnoreCase(getStripedAttributeValue(tag, ITEM_PROP))) {
+        myValues.add(tag.getValue().getTrimmedText());
+      }
+
+      super.visitXmlTag(tag);
+
+      if (isTypeTag) {
+        myCollecting = false;
+      }
+    }
+
+    public List<String> getValues() {
+      return new ArrayList<String>(myValues);
+    }
+  }
+
+  private static class FetchMicrodataResourceAction extends FetchExtResourceAction {
+    @Override
+    protected boolean resultIsValid(Project project,
+                                    ProgressIndicator indicator,
+                                    String resourceUrl,
+                                    FetchExtResourceAction.FetchResult result) {
+      return true;
+    }
+  }
+}
diff --git a/xml/impl/src/com/intellij/xml/util/XmlReferenceContributor.java b/xml/impl/src/com/intellij/xml/util/XmlReferenceContributor.java
index 872d17462e20..6b68974f4ecc 100644
--- a/xml/impl/src/com/intellij/xml/util/XmlReferenceContributor.java
+++ b/xml/impl/src/com/intellij/xml/util/XmlReferenceContributor.java
@@ -1,6 +1,8 @@
 package com.intellij.xml.util;
 
 import com.intellij.codeInsight.daemon.impl.analysis.encoding.XmlEncodingReferenceProvider;
+import com.intellij.html.impl.providers.MicrodataReferenceProvider;
+import com.intellij.html.impl.util.MicrodataUtil;
 import com.intellij.patterns.PlatformPatterns;
 import com.intellij.patterns.XmlPatterns;
 import com.intellij.psi.PsiReferenceContributor;
@@ -52,6 +54,13 @@ public class XmlReferenceContributor extends PsiReferenceContributor {
       )
     ), true, uriProvider);
 
+    XmlUtil.registerXmlAttributeValueReferenceProvider(
+      registrar,
+      new String[]{MicrodataUtil.ITEM_TYPE},
+      null,
+      new MicrodataReferenceProvider()
+    );
+
     final SchemaReferencesProvider schemaReferencesProvider = new SchemaReferencesProvider();
 
     XmlUtil.registerXmlAttributeValueReferenceProvider(registrar,
diff --git a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
new file mode 100644
index 000000000000..988fe496f109
--- /dev/null
+++ b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2000-2013 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.html;
+
+import com.intellij.codeInsight.completion.CompletionType;
+import com.intellij.javaee.ExternalResourceManager;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.fileTypes.StdFileTypes;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.testFramework.fixtures.CodeInsightFixtureTestCase;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author: Fedor.Korotkov
+ */
+public class MicrodataCompletionTest extends CodeInsightFixtureTestCase {
+
+  @Override
+  protected String getBasePath() {
+    return "/xml/tests/testData/microdata/";
+  }
+
+  @Override
+  protected boolean isCommunity() {
+    return true;
+  }
+
+  private void doTestInHtml(String text, String... items) throws Throwable {
+    configureAndComplete(text, items);
+    assertContainsElements(myFixture.getLookupElementStrings(), Arrays.asList(items));
+  }
+
+  private void doFailTestInHtml(String text, String... items) throws Throwable {
+    configureAndComplete(text, items);
+    final List<String> lookups = myFixture.getLookupElementStrings();
+    assertNotNull(lookups);
+    for (String item : items) {
+      assertFalse("Should not contain: " + item, lookups.contains(item));
+    }
+  }
+
+  private void configureAndComplete(String text, String[] items) throws Exception {
+    myFixture.configureByText(StdFileTypes.HTML, text);
+    myFixture.complete(CompletionType.BASIC);
+  }
+
+  public void testScopeType() throws Throwable {
+    doTestInHtml("<section <caret>></section>", "itemscope");
+  }
+
+  public void testScopeInDivTag() throws Throwable {
+    doTestInHtml("<div <caret>></div>", "itemscope");
+  }
+
+  public void testScopeInSpanTag() throws Throwable {
+    doTestInHtml("<span <caret>></span>", "itemscope");
+  }
+
+  public void testScopeInATag() throws Throwable {
+    doTestInHtml("<a <caret>></a>", "itemscope");
+  }
+
+  public void testTypeInATag() throws Throwable {
+    doFailTestInHtml("<a <caret>></a>", "itemtype", "itemid");
+  }
+
+  public void testTypeInScope() throws Throwable {
+    doTestInHtml("<section itemscope <caret>><div></div></section>", "itemtype", "itemid");
+  }
+
+  public void testPropInScope() throws Throwable {
+    doTestInHtml("<section itemscope><div <caret>></div></section>", "itemprop");
+  }
+
+  public void testTypeWithinScope() throws Throwable {
+    doFailTestInHtml("<section <caret>><div></div></section>", "itemtype", "itemid");
+  }
+
+  public void testPropWithinScope() throws Throwable {
+    doFailTestInHtml("<section><div <caret>></div></section>", "itemprop");
+  }
+
+  public void testPropWithinScopeWithRef() throws Throwable {
+    doTestInHtml("<body>" +
+                 "<section itemscope itemref=\"bar foo\"></section>" +
+                 "<section id=\"foo\"><div <caret>></div></section>" +
+                 "</body>", "itemprop");
+  }
+
+  public void testRefInScope() throws Throwable {
+    doTestInHtml("<section itemscope itemref=\"b<caret>\"></section><p id=\"bar\"></p><p id=\"baz\"></p>", "bar", "baz");
+  }
+
+  public void testPropValue() throws Throwable {
+    final VirtualFile virtualFile = myFixture.copyFileToProject("Person.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Person", virtualFile.getPath());
+      }
+    });
+    doTestInHtml("<section itemscope itemtype=\"http://data-vocabulary.org/Person\"><div itemprop=\"<caret>\"></div></section>",
+                 "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address"
+    );
+  }
+
+  public void testPropValueFromTwoTypes() throws Throwable {
+    final VirtualFile personFile = myFixture.copyFileToProject("Person.html");
+    final VirtualFile addressFile = myFixture.copyFileToProject("Address.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Person", personFile.getPath());
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Address", addressFile.getPath());
+      }
+    });
+    doTestInHtml(
+      "<section itemscope itemtype=\"http://data-vocabulary.org/Person http://data-vocabulary.org/Address\"><div itemprop=\"<caret>\"></div></section>",
+      "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address",
+      "street-address", "locality", "region", "postal-code", "country-name"
+    );
+  }
+
+  public void testPropValueFromRef() throws Throwable {
+    final VirtualFile virtualFile = myFixture.copyFileToProject("Person.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Person", virtualFile.getPath());
+      }
+    });
+    doTestInHtml("<body>" +
+                 "<section itemscope itemtype=\"http://data-vocabulary.org/Person\" itemref=\"foo\"></section>" +
+                 "<section id=\"foo\"><div itemprop=\"<caret>\"></div></section>" +
+                 "</body>",
+                 "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address"
+    );
+  }
+}
diff --git a/xml/tests/testData/microdata/Address.html b/xml/tests/testData/microdata/Address.html
new file mode 100644
index 000000000000..4e926bb53ccf
--- /dev/null
+++ b/xml/tests/testData/microdata/Address.html
@@ -0,0 +1,105 @@
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Address microdata description · Data-Vocabulary.org
+    </title>
+    <link href="/css/default.css" rel="stylesheet">
+    <script src="//www.google.com/js/gweb/analytics/autotrack.js">
+</script>
+    <script>
+new gweb.analytics.AutoTrack({profile: 'UA-12481063-1'});
+    </script>
+  </head>
+  <body>
+    <h1>
+      <a href="/">Data-Vocabulary.org</a>
+    </h1>
+    <h2>
+      Address
+    </h2>
+    <ul id="promo">
+      <li>Looking for Google’s <a href=
+      "http://google.com/support/webmasters/bin/answer.py?answer=99170">webmaster docs</a>?
+      </li>
+      <li>Looking for <a href="http://rdf.data-vocabulary.org/">RDF</a>?
+      </li>
+    </ul>
+    <div itemid="http://data-vocabulary.org/Address" itemscope itemtype=
+    "http://data-vocabulary.org/itemtype">
+      <p>
+        See our <a href=
+        "http://www.google.com/support/webmasters/bin/answer.py?hl=en&amp;answer=146861">Businesses
+        and Organizations webmaster docs</a> for a full explanation of the Address type, and how to
+        encode Address data in RDFa, microformats or microdata. This page exists to contain a
+        machine-readable microdata description of the Address type itself (at the URI
+        http://data-vocabulary.org/Address).
+      </p>
+      <p>
+        An item with the <a href=
+        "http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html#item-type">item
+        type</a> http://data-vocabulary.org/Address represents a physical address. The following
+        are the type’s <a href=
+        "http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html#defined-property-name">
+        defined property names</a>:
+      </p>
+      <table>
+        <tr>
+          <th>
+            Property
+          </th>
+          <th>
+            Description
+          </th>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Address/street-address" itemprop="itemprop"
+        itemscope itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">street-address</code>
+          </td>
+          <td itemprop="description">
+            The street address.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Address/locality" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">locality</code>
+          </td>
+          <td itemprop="description">
+            The locality (e.g., a city).
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Address/region" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">region</code>
+          </td>
+          <td itemprop="description">
+            The region (e.g., a state).
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Address/postal-code" itemprop="itemprop" itemscope=
+        "" itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">postal-code</code>
+          </td>
+          <td itemprop="description">
+            The postal code.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Address/country-name" itemprop="itemprop" itemscope=
+        "" itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">country-name</code>
+          </td>
+          <td itemprop="description">
+            The name of the country.
+          </td>
+        </tr>
+      </table>
+    </div>
+  </body>
+</html>
diff --git a/xml/tests/testData/microdata/Person.html b/xml/tests/testData/microdata/Person.html
new file mode 100644
index 000000000000..225560b6984d
--- /dev/null
+++ b/xml/tests/testData/microdata/Person.html
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Person microdata description · Data-Vocabulary.org
+    </title>
+    <link href="/css/default.css" rel="stylesheet">
+    <script src="//www.google.com/js/gweb/analytics/autotrack.js">
+</script>
+    <script>
+new gweb.analytics.AutoTrack({profile: 'UA-12481063-1'});
+    </script>
+  </head>
+  <body>
+    <h1>
+      <a href="/">Data-Vocabulary.org</a>
+    </h1>
+    <h2>
+      Person
+    </h2>
+    <ul id="promo">
+      <li>Looking for Google’s <a href=
+      "http://google.com/support/webmasters/bin/answer.py?answer=99170">webmaster docs</a>?
+      </li>
+      <li>Looking for <a href="http://rdf.data-vocabulary.org/">RDF</a>?
+      </li>
+    </ul>
+    <div itemid="http://data-vocabulary.org/Person" itemscope itemtype=
+    "http://data-vocabulary.org/itemtype">
+      <p>
+        See our <a href=
+        "http://www.google.com/support/webmasters/bin/answer.py?hl=en&amp;answer=146646">Person
+        webmaster docs</a> for full explanation of the Person type, and how to encode Person data
+        in RDFa, microformats or microdata. This page exists to contain a machine-readable
+        microdata description of the Person type itself (at the URI
+        http://data-vocabulary.org/Person).
+      </p>
+      <p>
+        An item with the <a href=
+        "http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html#item-type">item
+        type</a> http://data-vocabulary.org/Person represents a person. The following are the
+        type’s <a href=
+        "http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html#defined-property-name">
+        defined property names</a>:
+      </p>
+      <table>
+        <tr>
+          <th>
+            Property
+          </th>
+          <th>
+            Description
+          </th>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/name" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">name</code> (<code>fn</code>)
+          </td>
+          <td itemprop="description">
+            Name.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/nickname" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">nickname</code>
+          </td>
+          <td itemprop="description">
+            Nickname.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/photo" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">photo</code>
+          </td>
+          <td itemprop="description">
+            An image link.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/title" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">title</code>
+          </td>
+          <td itemprop="description">
+            The person’s title (for example, Financial Manager).
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/role" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">role</code>
+          </td>
+          <td itemprop="description">
+            The person’s role (for example, Accountant).
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/url" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">url</code>
+          </td>
+          <td itemprop="description">
+            Link to a web page, such as the person’s home page.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/affiliation" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">affiliation</code> (<code>org</code>)
+          </td>
+          <td itemprop="description">
+            The name of an organization with which the person is associated (for example, an
+            employer). If <code>fn</code> and <code>org</code> have the exact same value, Google
+            will interpret the information as referring to a business or organization, not a
+            person.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/friend" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">friend</code>
+          </td>
+          <td itemprop="description">
+            Identifies a social relationship between the person described and another person.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/contact" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">contact</code>
+          </td>
+          <td itemprop="description">
+            Identifies a social relationship between the person described and another person.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/acquaintance" itemprop="itemprop" itemscope=
+        "" itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">acquaintance</code>
+          </td>
+          <td itemprop="description">
+            Identifies a social relationship between the person described and another person.
+          </td>
+        </tr>
+        <tr itemid="http://data-vocabulary.org/Person/address" itemprop="itemprop" itemscope
+        itemtype="http://data-vocabulary.org/itemprop">
+          <td>
+            <code itemprop="name">address</code> (<code>adr</code>)
+          </td>
+          <td itemprop="description">
+            The location of the person. Can have the subproperties <code>street-address</code>,
+            <code>locality</code>, <code>region</code>, <code>postal-code</code>, and
+            <code>country-name</code>.
+          </td>
+        </tr>
+      </table>
+    </div>
+  </body>
+</html>

From 606bc0cace18463de4a8a85e98305ba0fbaa0387 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 12:33:15 +0400
Subject: [PATCH 095/354] IDEA-101677 Gradle: 'Import project' enhancements

---
 .../resources/i18n/GradleBundle.properties    |   5 +-
 .../GradleAdjustImportSettingsUtil.java       |  37 -------
 .../wizard/adjust/GradleModuleSettings.java   |  29 -----
 .../wizard/adjust/GradleProjectSettings.java  | 100 ++++++++++++++----
 4 files changed, 83 insertions(+), 88 deletions(-)

diff --git a/plugins/gradle/resources/i18n/GradleBundle.properties b/plugins/gradle/resources/i18n/GradleBundle.properties
index df9969acd658..d0624415b827 100644
--- a/plugins/gradle/resources/i18n/GradleBundle.properties
+++ b/plugins/gradle/resources/i18n/GradleBundle.properties
@@ -26,8 +26,9 @@ gradle.import.structure.settings.label.project.config.location=Project location:
 gradle.import.structure.settings.title.project.config.location=Project location
 gradle.import.structure.settings.label.project.compile.output.location=Project compiler output:
 gradle.import.structure.settings.title.project.compile.output.location=Project compiler output
-gradle.import.structure.settings.label.module.config.location=Module file location:
-gradle.import.structure.settings.title.module.config.location=Module file location
+gradle.import.structure.settings.label.iml.location=Module files location:
+gradle.import.structure.settings.label.iml.location.per.module=module content root
+gradle.import.structure.settings.label.iml.location.project.dir=project dir
 gradle.import.structure.settings.label.export=Exported:
 gradle.import.structure.settings.label.scope=Scope:
 gradle.import.structure.settings.label.root.source=Source roots:
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleAdjustImportSettingsUtil.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleAdjustImportSettingsUtil.java
index 1fefd3a3b99b..b309b0014431 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleAdjustImportSettingsUtil.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleAdjustImportSettingsUtil.java
@@ -11,8 +11,6 @@ import org.jetbrains.plugins.gradle.util.GradleBundle;
 import org.jetbrains.plugins.gradle.util.GradleUtil;
 
 import javax.swing.*;
-import javax.swing.event.DocumentEvent;
-import javax.swing.event.DocumentListener;
 
 /**
  * @author Denis Zhdanov
@@ -23,41 +21,6 @@ public class GradleAdjustImportSettingsUtil {
   private GradleAdjustImportSettingsUtil() {
   }
 
-  /**
-   * Setups given builder to expose controls for management of the given component's name.
-   *
-   * @param builder    target settings builder
-   * @param component  component which name management should be exposed
-   * @return    UI control that holds target component's name
-   */
-  @NotNull
-  public static JTextField configureNameControl(@NotNull GradleProjectSettingsBuilder builder, @NotNull final Named component) {
-    final JTextField result = new JTextField();
-    result.setText(component.getName());
-    builder.add("gradle.import.structure.settings.label.name", result);
-    result.getDocument().addDocumentListener(new DocumentListener() {
-      @Override
-      public void insertUpdate(DocumentEvent e) {
-        applyNewName();
-      }
-      @Override
-      public void removeUpdate(DocumentEvent e) {
-        applyNewName();
-      }
-      @Override
-      public void changedUpdate(DocumentEvent e) {
-      }
-      private void applyNewName() {
-        String text = result.getText();
-        if (text == null) {
-          return;
-        }
-        component.setName(text.trim());
-      }
-    });
-    return result;
-  }
-
   /**
    * Performs generic check of the name of the given component.
    * 
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleModuleSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleModuleSettings.java
index 502063ec0284..3bc37e8ad1b5 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleModuleSettings.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleModuleSettings.java
@@ -15,7 +15,6 @@ import org.jetbrains.plugins.gradle.util.GradleUtil;
 import javax.swing.*;
 import java.awt.event.ItemEvent;
 import java.awt.event.ItemListener;
-import java.io.File;
 
 /**
  * Manages settings of {@link GradleModule gradle module} component.
@@ -27,8 +26,6 @@ public class GradleModuleSettings implements GradleProjectStructureNodeSettings
 
   private final JComponent                myComponent;
   private final GradleModule              myModule;
-  private final JTextField                myNameControl;
-  private final TextFieldWithBrowseButton myModuleFileLocationField;
   private final JRadioButton              myInheritProjectCompileOutputPathButton;
   private final JRadioButton              myUseModuleCompileOutputPathButton;
   private final TextFieldWithBrowseButton myOutputLocationField;
@@ -37,8 +34,6 @@ public class GradleModuleSettings implements GradleProjectStructureNodeSettings
   public GradleModuleSettings(@NotNull GradleModule module) {
     myModule = module;
     GradleProjectSettingsBuilder builder = new GradleProjectSettingsBuilder();
-    myNameControl = GradleAdjustImportSettingsUtil.configureNameControl(builder, myModule);
-    myModuleFileLocationField = setupModuleFileLocation(builder);
     Pair<JRadioButton, JRadioButton> pair = setupCompileOutput(builder);
     myInheritProjectCompileOutputPathButton = pair.first;
     myUseModuleCompileOutputPathButton = pair.second;
@@ -70,15 +65,6 @@ public class GradleModuleSettings implements GradleProjectStructureNodeSettings
     return new Pair<JRadioButton, JRadioButton>(inheritButton, moduleButton);
   }
   
-  @NotNull
-  private static TextFieldWithBrowseButton setupModuleFileLocation(@NotNull GradleProjectSettingsBuilder builder) {
-    TextFieldWithBrowseButton result = new TextFieldWithBrowseButton();
-    String title = GradleBundle.message("gradle.import.structure.settings.title.module.config.location");
-    result.addBrowseFolderListener(title, "", null, BrowseFilesListener.SINGLE_DIRECTORY_DESCRIPTOR);
-    builder.add("gradle.import.structure.settings.label.module.config.location", result);
-    return result;
-  }
-  
   @NotNull
   private static Pair<TextFieldWithBrowseButton, TextFieldWithBrowseButton> setupOutputLocation(
     @NotNull GradleProjectSettingsBuilder builder)
@@ -98,19 +84,6 @@ public class GradleModuleSettings implements GradleProjectStructureNodeSettings
 
   @Override
   public boolean validate() {
-    if (!GradleAdjustImportSettingsUtil.validate(myModule, myNameControl)) {
-      return false;
-    }
-    String moduleFileDir = myModuleFileLocationField.getText();
-    if (moduleFileDir == null || StringUtil.isEmpty(moduleFileDir.trim())) {
-      GradleUtil.showBalloon(
-        myModuleFileLocationField,
-        MessageType.ERROR,
-        GradleBundle.message("gradle.import.text.error.module.undefined.config.location")
-      );
-      return false;
-    }
-    myModule.setModuleFileDirectoryPath(moduleFileDir.trim());
     if (myUseModuleCompileOutputPathButton.isSelected()) {
       String outputLocation = myOutputLocationField.getText();
       if (outputLocation == null || StringUtil.isEmpty(outputLocation.trim())) {
@@ -139,8 +112,6 @@ public class GradleModuleSettings implements GradleProjectStructureNodeSettings
 
   @Override
   public void refresh() {
-    myNameControl.setText(myModule.getName());
-    myModuleFileLocationField.setText(new File(myModule.getModuleFilePath()).getParent());
     if (myModule.isInheritProjectCompileOutputPath()) {
       myInheritProjectCompileOutputPathButton.setSelected(true);
     }
diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleProjectSettings.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleProjectSettings.java
index 429563fa33b2..133b04eb3fcd 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleProjectSettings.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/wizard/adjust/GradleProjectSettings.java
@@ -1,27 +1,35 @@
 package org.jetbrains.plugins.gradle.manage.wizard.adjust;
 
 import com.intellij.ide.util.BrowseFilesListener;
+import com.intellij.ide.util.PropertiesComponent;
 import com.intellij.openapi.projectRoots.JavaSdk;
 import com.intellij.openapi.projectRoots.JavaSdkVersion;
 import com.intellij.openapi.projectRoots.ProjectJdkTable;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.io.FileUtilRt;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.pom.java.LanguageLevel;
+import com.intellij.ui.components.JBRadioButton;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.PropertyKey;
+import org.jetbrains.plugins.gradle.model.gradle.GradleContentRoot;
+import org.jetbrains.plugins.gradle.model.gradle.GradleModule;
 import org.jetbrains.plugins.gradle.model.gradle.GradleProject;
 import org.jetbrains.plugins.gradle.util.GradleBundle;
 import org.jetbrains.plugins.gradle.util.GradleUtil;
 
 import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.awt.event.ItemEvent;
 import java.awt.event.ItemListener;
 import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.*;
 import java.util.List;
-import java.util.Map;
 
 /**
  * Manages settings of {@link GradleProject gradle project} component.
@@ -30,28 +38,33 @@ import java.util.Map;
  * @since 8/12/11 2:58 PM
  */
 public class GradleProjectSettings implements GradleProjectStructureNodeSettings {
-
-  private final JComponent                myComponent;
-  private final GradleProject             myProject;
-  private final JTextField                myNameControl;
-  private final JComboBox                 myLanguageLevelComboBox;
-  private final DefaultComboBoxModel      mySdkModel;
-  private final TextFieldWithBrowseButton myProjectConfigLocationField;
-  private final TextFieldWithBrowseButton myProjectCompileOutputLocationField;
   
+  private static final String KEEP_IML_AT_MODULE_DIR_PROPERTY_KEY = "gradle.iml.at.module.dir";
+  
+  @NotNull private final JComponent                myComponent;
+  @NotNull private final GradleProject             myProject;
+  @NotNull private final JComboBox                 myLanguageLevelComboBox;
+  @NotNull private final DefaultComboBoxModel      mySdkModel;
+  @NotNull private final TextFieldWithBrowseButton myProjectConfigLocationField;
+  @NotNull private final TextFieldWithBrowseButton myProjectCompileOutputLocationField;
+  @NotNull private final JRadioButton              myImlAtModuleContentRootsButton;
+  @NotNull private final JRadioButton              myImlAtProjectDirButton;
+
   public GradleProjectSettings(@NotNull GradleProject project) {
     myProject = project;
     GradleProjectSettingsBuilder builder = new GradleProjectSettingsBuilder();
-    myNameControl = GradleAdjustImportSettingsUtil.configureNameControl(builder, project);
     myLanguageLevelComboBox = setupLanguageLevelControls(builder);
     setupSdkControls(mySdkModel = new DefaultComboBoxModel(), builder);
     myProjectConfigLocationField = setupProjectConfigLocation(builder);
     myProjectCompileOutputLocationField = setupProjectCompileOutputLocation(builder);
-    filterSdksByLanguageLevel();    
+    filterSdksByLanguageLevel();
+    myImlAtModuleContentRootsButton = new JBRadioButton(GradleBundle.message("gradle.import.structure.settings.label.iml.location.per.module"));
+    myImlAtProjectDirButton = new JBRadioButton(GradleBundle.message("gradle.import.structure.settings.label.iml.location.project.dir"));
+    setModuleFilesLocationControl(builder);
     myComponent = builder.build();
     refresh();
   }
-  
+
   private JComboBox setupLanguageLevelControls(@NotNull GradleProjectSettingsBuilder builder) {
     JComboBox result = new JComboBox();
     final Map<Object, LanguageLevel> levels = new HashMap<Object, LanguageLevel>();
@@ -140,14 +153,62 @@ public class GradleProjectSettings implements GradleProjectStructureNodeSettings
     builder.add("gradle.import.structure.settings.label.project.compile.output.location", result);
     return result;
   }
+
+  private void setModuleFilesLocationControl(@NotNull GradleProjectSettingsBuilder builder) {
+    ButtonGroup group = new ButtonGroup();
+    group.add(myImlAtModuleContentRootsButton);
+    group.add(myImlAtProjectDirButton);
+    JPanel panel = new JPanel(new GridLayout(2, 1));
+    panel.add(myImlAtModuleContentRootsButton);
+    panel.add(myImlAtProjectDirButton);
+    myImlAtModuleContentRootsButton.addItemListener(new ItemListener() {
+      @Override
+      public void itemStateChanged(ItemEvent e) {
+        if (e.getStateChange() != ItemEvent.SELECTED) {
+          return;
+        }
+        for (GradleModule module : myProject.getModules()) {
+          Collection<GradleContentRoot> contentRoots = module.getContentRoots();
+          if (contentRoots.isEmpty()) {
+            continue;
+          }
+          module.setModuleFileDirectoryPath(contentRoots.iterator().next().getRootPath());
+        }
+        PropertiesComponent.getInstance().setValue(KEEP_IML_AT_MODULE_DIR_PROPERTY_KEY, String.valueOf(true));
+      }
+    });
+    myImlAtProjectDirButton.addItemListener(new ItemListener() {
+      @Override
+      public void itemStateChanged(ItemEvent e) {
+        if (e.getStateChange() != ItemEvent.SELECTED) {
+          return;
+        }
+        String dirPath = myProjectConfigLocationField.getText();
+        if (StringUtil.isEmpty(dirPath)) {
+          return;
+        }
+        boolean goodDir = FileUtilRt.createDirectory(new File(dirPath));
+        if (!goodDir) {
+          return;
+        }
+        for (GradleModule module : myProject.getModules()) {
+          module.setModuleFileDirectoryPath(dirPath);
+        }
+        PropertiesComponent.getInstance().setValue(KEEP_IML_AT_MODULE_DIR_PROPERTY_KEY, String.valueOf(false));
+      }
+    });
+    boolean imlAtModuleDir = PropertiesComponent.getInstance().getBoolean(KEEP_IML_AT_MODULE_DIR_PROPERTY_KEY, true);
+    if (imlAtModuleDir) {
+      myImlAtModuleContentRootsButton.setSelected(true);
+    }
+    else {
+      myImlAtProjectDirButton.setSelected(true);
+    }
+    builder.add("gradle.import.structure.settings.label.iml.location", panel);
+  }
   
   @Override
   public boolean validate() {
-    boolean nameIsValid = GradleAdjustImportSettingsUtil.validate(myProject, myNameControl);
-    if (!nameIsValid) {
-      return false;
-    }
-    
     if (!validateDirLocation(myProjectConfigLocationField, "gradle.import.text.error.project.undefined.config.location",
                              "gradle.import.text.error.file.config.location"))
     {
@@ -167,7 +228,6 @@ public class GradleProjectSettings implements GradleProjectStructureNodeSettings
 
   @Override
   public void refresh() {
-    myNameControl.setText(myProject.getName());
     myProjectConfigLocationField.setText(myProject.getProjectFileDirectoryPath());
     myProjectCompileOutputLocationField.setText(myProject.getCompileOutputPath());
     myLanguageLevelComboBox.setSelectedItem(myProject.getLanguageLevel().getPresentableText());

From f3e2d28bb19c5e24666c8176603b88c4f060c2c6 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Mon, 25 Feb 2013 12:43:38 +0400
Subject: [PATCH 096/354] cleanup

---
 .../org/jetbrains/idea/maven/importing/FacetImporter.java     | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/FacetImporter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/FacetImporter.java
index c2987b0af5fa..97057bb43bcd 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/FacetImporter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/FacetImporter.java
@@ -40,6 +40,10 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
   protected final FACET_TYPE_TYPE myFacetType;
   protected final String myDefaultFacetName;
 
+  protected FacetImporter(String pluginGroupID, String pluginArtifactID, FACET_TYPE_TYPE type) {
+    this(pluginGroupID, pluginArtifactID, type, type.getDefaultFacetName());
+  }
+
   public FacetImporter(String pluginGroupID,
                        String pluginArtifactID,
                        FACET_TYPE_TYPE type,

From 15abde0bf1c823221f8a05f66f7998c6026cf72e Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 12:42:17 +0400
Subject: [PATCH 097/354] IDEA-95898 Gradle based projects should offer
 Auto-Import as Maven projects do

Refresh change ttl when it's checked to be valid
---
 .../autoimport/GradleUserProjectChangesCalculator.java       | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
index 316d87aa4e0b..d784448964ea 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/autoimport/GradleUserProjectChangesCalculator.java
@@ -137,7 +137,10 @@ public class GradleUserProjectChangesCalculator {
   public void filterOutdatedChanges() {
     Set<GradleUserProjectChange> changes = ContainerUtilRt.newHashSet(mySettings.getUserProjectChanges());
     for (GradleUserProjectChange change : mySettings.getUserProjectChanges()) {
-      if (!isUpToDate(change)) {
+      if (isUpToDate(change)) {
+        change.setTimestamp(System.currentTimeMillis());
+      }
+      else {
         changes.remove(change);
       }
     }

From 490f6460622b9cb752f8a22610a46ea9496fc4a4 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 12:51:05 +0400
Subject: [PATCH 098/354] IDEA-101776 Gradle: Avoid ide hang on auto-import

Don't call invokeAndWait() from EDT
---
 .../src/org/jetbrains/plugins/gradle/util/GradleUtil.java  | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
index a4302558a359..4a4c3227e360 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
@@ -581,7 +581,12 @@ public class GradleUtil {
     };
 
     if (synchronous) {
-      UIUtil.invokeAndWaitIfNeeded(wrappedTask);
+      if (ApplicationManager.getApplication().isDispatchThread()) {
+        wrappedTask.run();
+      }
+      else {
+        UIUtil.invokeAndWaitIfNeeded(wrappedTask);
+      }
     }
     else {
       UIUtil.invokeLaterIfNeeded(wrappedTask);

From 3a8c007ddcc27ec3a3f1842647ad8ab7a2b7a742 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 12:54:09 +0400
Subject: [PATCH 099/354] IDEA-101768 Avoid memory leak in 'editor tabs: none'
 mode

---
 .../openapi/fileEditor/impl/EditorComposite.java |  5 +++++
 .../fileEditor/impl/FileEditorManagerImpl.java   |  6 ++++++
 .../impl/text/TextEditorComponent.java           | 16 ++++++++++++----
 3 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorComposite.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorComposite.java
index 14dca00e485d..a21d7e2cb349 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorComposite.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorComposite.java
@@ -405,6 +405,11 @@ public abstract class EditorComposite implements Disposable {
   }
 
   public void dispose() {
+    for (FileEditor editor : myEditors) {
+      if (!Disposer.isDisposed(editor)) {
+        Disposer.dispose(editor);
+      }
+    }
   }
 
   private static class TopBottomPanel extends JPanel {
diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/FileEditorManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/FileEditorManagerImpl.java
index 5017b9e4b2a3..ed39011cc635 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/FileEditorManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/FileEditorManagerImpl.java
@@ -719,6 +719,12 @@ public class FileEditorManagerImpl extends FileEditorManagerEx implements Projec
       providers = newSelectedComposite.getProviders();
     }
     else {
+      if (UISettings.getInstance().EDITOR_TAB_PLACEMENT == UISettings.TABS_NONE) {
+        for (EditorWithProviderComposite composite : window.getEditors()) {
+          Disposer.dispose(composite);
+        }
+      }
+
       // File is not opened yet. In this case we have to create editors
       // and select the created EditorComposite.
       final FileEditorProviderManager editorProviderManager = FileEditorProviderManager.getInstance();
diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
index 89129280b1f8..960e977d294e 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
@@ -23,7 +23,10 @@ import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.editor.event.*;
+import com.intellij.openapi.editor.event.DocumentAdapter;
+import com.intellij.openapi.editor.event.DocumentEvent;
+import com.intellij.openapi.editor.event.EditorMouseEvent;
+import com.intellij.openapi.editor.event.EditorMouseEventArea;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.editor.ex.EditorMarkupModel;
 import com.intellij.openapi.editor.highlighter.EditorHighlighter;
@@ -59,7 +62,7 @@ import java.beans.PropertyChangeListener;
  * @author Anton Katilin
  * @author Vladimir Kondratyev
  */
-class TextEditorComponent extends JBLoadingPanel implements DataProvider{
+class TextEditorComponent extends JBLoadingPanel implements DataProvider {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.fileEditor.impl.text.TextEditorComponent");
 
   private final Project myProject;
@@ -160,14 +163,19 @@ class TextEditorComponent extends JBLoadingPanel implements DataProvider{
   Editor getEditor(){
     return myEditor;
   }
-
+  
   /**
    * @return created editor. This editor should be released by {@link #disposeEditor(Editor) }
    * method.
    */
   @NotNull
   private Editor createEditor(){
-    Editor editor = EditorFactory.getInstance().createEditor(myDocument, myProject);
+    EditorFactory editorFactory = EditorFactory.getInstance();
+    Editor[] editors = editorFactory.getEditors(myDocument);
+    if (editors.length == 1) {
+      return editors[0];
+    }
+    final Editor editor = editorFactory.createEditor(myDocument, myProject);
     ((EditorMarkupModel) editor.getMarkupModel()).setErrorStripeVisible(true);
     EditorHighlighter highlighter = EditorHighlighterFactory.getInstance().createEditorHighlighter(myFile, EditorColorsManager.getInstance().getGlobalScheme(), myProject);
     ((EditorEx) editor).setHighlighter(highlighter);

From 301681ba26a73a32ffdcfc3525c54bf293ce9a97 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Mon, 25 Feb 2013 11:10:36 +0100
Subject: [PATCH 100/354] Internal methods visibility reduced (merger
 leftovers)

---
 .../roots/impl/DirectoryIndexImpl.java        | 57 +++++++++----------
 1 file changed, 28 insertions(+), 29 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java b/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
index edb2bb87bf70..7a4a7a01e852 100644
--- a/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
+++ b/platform/lang-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java
@@ -139,7 +139,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     }
   }
 
-  protected void dispatchPendingEvents() {
+  private void dispatchPendingEvents() {
     myConnection.deliverImmediately();
   }
 
@@ -414,7 +414,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     return myInitialized;
   }
 
-  protected void doInitialize() {
+  private void doInitialize() {
     IndexState newState = new IndexState();
     newState.doInitialize(false);
     myState = newState;
@@ -428,7 +428,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
   }
 
   @NotNull
-  protected static ContentEntry[] getContentEntries(@NotNull Module module) {
+  private static ContentEntry[] getContentEntries(@NotNull Module module) {
     return ModuleRootManager.getInstance(module).getContentEntries();
   }
 
@@ -478,12 +478,12 @@ public class DirectoryIndexImpl extends DirectoryIndex {
   }
 
   @Nullable
-  protected static String getPackageNameForSubdir(String parentPackageName, String subdirName) {
+  private static String getPackageNameForSubdir(String parentPackageName, String subdirName) {
     if (parentPackageName == null) return null;
     return parentPackageName.isEmpty() ? subdirName : parentPackageName + "." + subdirName;
   }
 
-  class IndexState {
+  private class IndexState {
     private final TIntObjectHashMap<Set<String>> myExcludeRootsMap = new TIntObjectHashMap<Set<String>>();
     private final TIntHashSet myProjectExcludeRoots = new TIntHashSet();
     private final TIntObjectHashMap<DirectoryInfo> myDirToInfoMap = new TIntObjectHashMap<DirectoryInfo>();
@@ -551,11 +551,10 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     }
 
     @Nullable
-    DirectoryInfo getInfo(int fileId) {
+    private DirectoryInfo getInfo(int fileId) {
       return myDirToInfoMap.get(fileId);
     }
 
-
     private void storeInfo(@NotNull DirectoryInfo info, int id) {
       if (CHECK) {
         VirtualFile file = findFileById(id);
@@ -567,7 +566,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       myDirToInfoMap.put(id, info);
     }
 
-    void assertAncestorsConsistent() {
+    private void assertAncestorsConsistent() {
       if (CHECK) {
         myDirToInfoMap.forEachEntry(new TIntObjectProcedure<DirectoryInfo>() {
           @Override
@@ -594,10 +593,10 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       }
     }
 
-    void fillMapWithModuleContent(@NotNull NewVirtualFile root,
-                                  final Module module,
-                                  final NewVirtualFile contentRoot,
-                                  @Nullable final ProgressIndicator progress) {
+    private void fillMapWithModuleContent(@NotNull NewVirtualFile root,
+                                          final Module module,
+                                          final NewVirtualFile contentRoot,
+                                          @Nullable final ProgressIndicator progress) {
       final int contentRootId = contentRoot == null ? 0 : contentRoot.getId();
       if (contentRoot != null) {
         assert VfsUtilCore.isAncestor(contentRoot, root, false) : "Root: "+root+"; contentRoot: "+contentRoot;
@@ -725,13 +724,13 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       }
     }
 
-    protected void fillMapWithModuleSource(@NotNull final Module module,
-                                           @NotNull final NewVirtualFile contentRoot,
-                                           @NotNull final NewVirtualFile dir,
-                                           @NotNull final String packageName,
-                                           @NotNull final NewVirtualFile sourceRoot,
-                                           final boolean isTestSource,
-                                           @Nullable final ProgressIndicator progress) {
+    private void fillMapWithModuleSource(@NotNull final Module module,
+                                         @NotNull final NewVirtualFile contentRoot,
+                                         @NotNull final NewVirtualFile dir,
+                                         @NotNull final String packageName,
+                                         @NotNull final NewVirtualFile sourceRoot,
+                                         final boolean isTestSource,
+                                         @Nullable final ProgressIndicator progress) {
       assert VfsUtilCore.isAncestor(sourceRoot, dir, false) : "SourceRoot: "+sourceRoot+" ("+sourceRoot.getFileSystem()+"); dir: "+dir+" ("+dir.getFileSystem()+")";
       VfsUtilCore.visitChildrenRecursively(dir, new DirectoryVisitor() {
         private final Stack<String> myPackages = new Stack<String>();
@@ -945,7 +944,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       }
     }
 
-    protected void setPackageName(int dirId, @Nullable String newPackageName) {
+    private void setPackageName(int dirId, @Nullable String newPackageName) {
       String oldPackageName = myDirToPackageName.get(dirId);
       if (oldPackageName != null) {
         removeDirFromPackage(oldPackageName, dirId);
@@ -962,13 +961,13 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     }
 
     // orderEntries must be sorted BY_OWNER_MODULE
-    protected void fillMapWithOrderEntries(@NotNull NewVirtualFile root,
-                                           @NotNull final OrderEntry[] orderEntries,
-                                           @Nullable final Module module,
-                                           @Nullable final NewVirtualFile libraryClassRoot,
-                                           @Nullable final NewVirtualFile librarySourceRoot,
-                                           @Nullable final DirectoryInfo parentInfo,
-                                           @Nullable final ProgressIndicator progress) {
+    private void fillMapWithOrderEntries(@NotNull NewVirtualFile root,
+                                         @NotNull final OrderEntry[] orderEntries,
+                                         @Nullable final Module module,
+                                         @Nullable final NewVirtualFile libraryClassRoot,
+                                         @Nullable final NewVirtualFile librarySourceRoot,
+                                         @Nullable final DirectoryInfo parentInfo,
+                                         @Nullable final ProgressIndicator progress) {
       VfsUtilCore.visitChildrenRecursively(root, new DirectoryVisitor() {
         private final Stack<OrderEntry[]> myEntries = new Stack<OrderEntry[]>();
 
@@ -1014,7 +1013,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
       });
     }
 
-    protected void doInitialize(boolean reverseAllSets/* for testing order independence*/) {
+    private void doInitialize(boolean reverseAllSets/* for testing order independence*/) {
       assertAncestorsConsistent();
       ProgressIndicator progress = ProgressIndicatorProvider.getGlobalProgressIndicator();
       if (progress == null) progress = new EmptyProgressIndicator();
@@ -1148,7 +1147,7 @@ public class DirectoryIndexImpl extends DirectoryIndex {
     }
 
     @NotNull
-    IndexState copy(@Nullable final TIntProcedure idFilter) {
+    private IndexState copy(@Nullable final TIntProcedure idFilter) {
       final IndexState copy = new IndexState();
 
       myExcludeRootsMap.forEachEntry(new TIntObjectProcedure<Set<String>>() {

From b35ffd402ecd60c6ff9543bc0bfe3fcf4728a7a1 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 14:14:08 +0400
Subject: [PATCH 101/354] IDEA-100722 Commenting block of Java code with EOL
 comments unfolds imports and top comment

system property -> registry
---
 .../generation/CommentByLineCommentHandler.java       | 11 +++++------
 .../src/misc/registry.properties                      |  2 ++
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/generation/CommentByLineCommentHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/generation/CommentByLineCommentHandler.java
index db00b690b06a..3e12b980eae1 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/generation/CommentByLineCommentHandler.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/generation/CommentByLineCommentHandler.java
@@ -36,6 +36,7 @@ import com.intellij.openapi.fileTypes.impl.CustomSyntaxTableFileType;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
@@ -46,7 +47,6 @@ import com.intellij.psi.codeStyle.Indent;
 import com.intellij.psi.util.PsiUtilBase;
 import com.intellij.util.DocumentUtil;
 import com.intellij.util.StringBuilderSpinAllocator;
-import com.intellij.util.SystemProperties;
 import com.intellij.util.containers.IntArrayList;
 import com.intellij.util.text.CharArrayUtil;
 import gnu.trove.THashMap;
@@ -57,9 +57,6 @@ import java.util.Map;
 
 public class CommentByLineCommentHandler implements CodeInsightActionHandler {
 
-  private static final int MIN_LINES_TO_COMMENT_TO_USE_BULK_PROCESSING
-    = SystemProperties.getIntProperty("idea.bulk.comment.lines.trigger", 100);
-
   private Project                                         myProject;
   private PsiFile                                         myFile;
   private Document                                        myDocument;
@@ -424,7 +421,8 @@ public class CommentByLineCommentHandler implements CodeInsightActionHandler {
   }
 
   public void doDefaultCommenting(final Commenter commenter) {
-    DocumentUtil.executeInBulk(myDocument, myEndLine - myStartLine >= MIN_LINES_TO_COMMENT_TO_USE_BULK_PROCESSING, new Runnable() {
+    DocumentUtil.executeInBulk(
+      myDocument, myEndLine - myStartLine >= Registry.intValue("comment.by.line.bulk.lines.trigger"), new Runnable() {
       @Override
       public void run() {
         for (int line = myEndLine; line >= myStartLine; line--) {
@@ -440,7 +438,8 @@ public class CommentByLineCommentHandler implements CodeInsightActionHandler {
     final FileType fileType = myFile.getFileType();
     final Indent minIndent = computeMinIndent(myStartLine, myEndLine, chars, myCodeStyleManager, fileType);
 
-    DocumentUtil.executeInBulk(myDocument, myEndLine - myStartLine > MIN_LINES_TO_COMMENT_TO_USE_BULK_PROCESSING, new Runnable() {
+    DocumentUtil.executeInBulk(
+      myDocument, myEndLine - myStartLine > Registry.intValue("comment.by.line.bulk.lines.trigger"), new Runnable() {
       @Override
       public void run() {
         for (int line = myEndLine; line >= myStartLine; line--) {
diff --git a/platform/platform-resources-en/src/misc/registry.properties b/platform/platform-resources-en/src/misc/registry.properties
index d42d179cf40a..a85031c0686b 100644
--- a/platform/platform-resources-en/src/misc/registry.properties
+++ b/platform/platform-resources-en/src/misc/registry.properties
@@ -271,3 +271,5 @@ diagrams.rendering.no.cache=true
 wolf.the.problem.solver=true
 ui.no.bangs.and.whistles=false
 disable.graph.inference=false
+
+comment.by.line.bulk.lines.trigger=100
\ No newline at end of file

From e0e6b6e7c6d4e7022fcad400d5283ce89a7e15fe Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 13:00:35 +0400
Subject: [PATCH 102/354] diagnostics

---
 .../navigation/actions/GotoTypeDeclarationAction.java           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoTypeDeclarationAction.java b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoTypeDeclarationAction.java
index e0d06b82b14f..ba7bc9d08159 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoTypeDeclarationAction.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoTypeDeclarationAction.java
@@ -84,7 +84,7 @@ public class GotoTypeDeclarationAction extends BaseCodeInsightAction implements
 
   private static void navigate(@NotNull Project project, @NotNull PsiElement symbolType) {
     PsiElement element = symbolType.getNavigationElement();
-    assert element != null;
+    assert element != null : "SymbolType :"+symbolType+"; file: "+symbolType.getContainingFile();
     VirtualFile file = element.getContainingFile().getVirtualFile();
     if (file != null) {
       OpenFileDescriptor descriptor = new OpenFileDescriptor(project, file, element.getTextOffset());

From 4c9116505ad9e6d3a4331b1cfe9bc8b125876fc0 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 13:55:10 +0400
Subject: [PATCH 103/354] not null, cleanup

---
 .../src/com/intellij/openapi/vfs/newvfs/RefreshQueue.java | 4 ++--
 .../intellij/openapi/vfs/newvfs/impl/VirtualFileImpl.java | 2 +-
 .../testSrc/com/intellij/openapi/vfs/VfsUtilTest.java     | 2 +-
 .../intellij/openapi/vfs/impl/VirtualFilePointerTest.java | 4 ++++
 platform/util/src/com/intellij/util/ArrayUtil.java        | 8 ++++++++
 5 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/openapi/vfs/newvfs/RefreshQueue.java b/platform/platform-api/src/com/intellij/openapi/vfs/newvfs/RefreshQueue.java
index 4e1a9d40afbc..0f7fe1f1f941 100644
--- a/platform/platform-api/src/com/intellij/openapi/vfs/newvfs/RefreshQueue.java
+++ b/platform/platform-api/src/com/intellij/openapi/vfs/newvfs/RefreshQueue.java
@@ -38,7 +38,7 @@ public abstract class RefreshQueue {
 
   public abstract RefreshSession createSession(boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull ModalityState state);
 
-  public final void refresh(boolean async, boolean recursive, @Nullable Runnable finishRunnable, VirtualFile... files) {
+  public final void refresh(boolean async, boolean recursive, @Nullable Runnable finishRunnable, @NotNull VirtualFile... files) {
     refresh(async, recursive, finishRunnable, getDefaultModalityState(), files);
   }
 
@@ -50,7 +50,7 @@ public abstract class RefreshQueue {
                             boolean recursive,
                             @Nullable Runnable finishRunnable,
                             @NotNull ModalityState state,
-                            VirtualFile... files) {
+                            @NotNull VirtualFile... files) {
     RefreshSession session = createSession(async, recursive, finishRunnable, state);
     session.addAllFiles(files);
     session.launch();
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileImpl.java
index f89e53226bd8..a6c063d418a8 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualFileImpl.java
@@ -36,7 +36,7 @@ import java.util.Collection;
 import java.util.Collections;
 
 public class VirtualFileImpl extends VirtualFileSystemEntry {
-  public VirtualFileImpl(String name, VirtualDirectoryImpl parent, int id, @PersistentFS.Attributes final int attributes) {
+  VirtualFileImpl(String name, VirtualDirectoryImpl parent, int id, @PersistentFS.Attributes final int attributes) {
     super(name, parent, id, attributes);
   }
 
diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/VfsUtilTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/VfsUtilTest.java
index 9bf7bbdbd50a..5a3235ecce35 100644
--- a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/VfsUtilTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/VfsUtilTest.java
@@ -371,7 +371,7 @@ public class VfsUtilTest extends PlatformLangTestCase {
         }
       }.execute().throwException();
     }
-    final VirtualFile theChild = vDir.getChildren()[5111];
+    final VirtualFile theChild = vDir.findChild("5111.txt");
 
     PlatformTestUtil.startPerformanceTest("find child is slow", 450, new ThrowableRunnable() {
       @Override
diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java
index 61de655b0cc3..a76cddf1c283 100644
--- a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java
@@ -273,6 +273,9 @@ public class VirtualFilePointerTest extends PlatformLangTestCase {
 
     jarParent.mkdir();
     FileUtil.copy(originalJar, jar);
+    assert jar.exists();
+    assert jarParent.exists();
+    assert jarParent.getParentFile().exists();
 
     refreshVFS();
 
@@ -330,6 +333,7 @@ public class VirtualFilePointerTest extends PlatformLangTestCase {
 
     jarParent.mkdir();
     FileUtil.copy(originalJar, jar);
+    assert jar.exists();
 
     refreshVFS();
 
diff --git a/platform/util/src/com/intellij/util/ArrayUtil.java b/platform/util/src/com/intellij/util/ArrayUtil.java
index f62a09fda4ff..3f1470ad9a56 100644
--- a/platform/util/src/com/intellij/util/ArrayUtil.java
+++ b/platform/util/src/com/intellij/util/ArrayUtil.java
@@ -114,6 +114,14 @@ public class ArrayUtil extends ArrayUtilRt {
     array[array.length - 1] = value;
     return array;
   }
+  @NotNull
+  public static int[] insert(@NotNull int[] array, int index, int value) {
+    int[] result = new int[array.length + 1];
+    System.arraycopy(array, 0, result, 0, index);
+    result[index] = value;
+    System.arraycopy(array, index, result, index+1, array.length - index);
+    return result;
+  }
 
   @NotNull
   public static byte[] append(@NotNull byte[] array, byte value) {

From 45b3f3333ff8812907d939768bf5153c51c5679a Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 14:01:52 +0400
Subject: [PATCH 104/354] win32cache: less memory

---
 .../openapi/vfs/impl/win32/Win32FsCache.java  | 32 ++++++++++---------
 .../vfs/impl/win32/Win32LocalFileSystem.java  |  4 +--
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32FsCache.java b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32FsCache.java
index 5612b530f0f6..d135f39c4fb7 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32FsCache.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32FsCache.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.openapi.vfs.impl.win32;
 
+import com.intellij.openapi.util.io.FileAttributes;
 import com.intellij.openapi.util.io.win32.FileInfo;
 import com.intellij.openapi.util.io.win32.IdeaWin32;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -34,19 +35,19 @@ import java.util.Map;
  */
 class Win32FsCache {
   private final IdeaWin32 myKernel = IdeaWin32.getInstance();
-  private Reference<Map<String, FileInfo>> myCache;
+  private Reference<Map<String, FileAttributes>> myCache;
 
   void clearCache() {
     myCache = null;
   }
 
   @NotNull
-  private Map<String, FileInfo> getMap() {
-    Reference<Map<String, FileInfo>> cache = myCache;
-    Map<String, FileInfo> map = cache == null ? null : cache.get();
+  private Map<String, FileAttributes> getMap() {
+    Reference<Map<String, FileAttributes>> cache = myCache;
+    Map<String, FileAttributes> map = cache == null ? null : cache.get();
     if (map == null) {
-      map = new THashMap<String, FileInfo>();
-      myCache = new SoftReference<Map<String, FileInfo>>(map);
+      map = new THashMap<String, FileAttributes>();
+      myCache = new SoftReference<Map<String, FileAttributes>>(map);
     }
     return map;
   }
@@ -60,10 +61,10 @@ class Win32FsCache {
 
     if (!path.endsWith("/")) path += "/";
     List<String> names = new ArrayList<String>(fileInfo.length);
-    Map<String, FileInfo> map = getMap();
+    Map<String, FileAttributes> map = getMap();
     for (FileInfo info : fileInfo) {
       String name = info.getName();
-      map.put(path + name, info);
+      map.put(path + name, info.toFileAttributes());
       names.add(name);
     }
 
@@ -71,17 +72,18 @@ class Win32FsCache {
   }
 
   @Nullable
-  FileInfo getInfo(@NotNull VirtualFile file) {
+  FileAttributes getAttributes(@NotNull VirtualFile file) {
     String path = file.getPath();
-    Map<String, FileInfo> map = getMap();
-    FileInfo info = map.get(path);
-    if (info == null) {
-      info = myKernel.getInfo(path);
+    Map<String, FileAttributes> map = getMap();
+    FileAttributes attributes = map.get(path);
+    if (attributes == null) {
+      FileInfo info = myKernel.getInfo(path);
       if (info == null) {
         return null;
       }
-      map.put(path, info);
+      attributes = info.toFileAttributes();
+      map.put(path, attributes);
     }
-    return info;
+    return attributes;
   }
 }
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32LocalFileSystem.java b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32LocalFileSystem.java
index c8353d5c94d5..3bbba55e0992 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32LocalFileSystem.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/win32/Win32LocalFileSystem.java
@@ -16,7 +16,6 @@
 package com.intellij.openapi.vfs.impl.win32;
 
 import com.intellij.openapi.util.io.FileAttributes;
-import com.intellij.openapi.util.io.win32.FileInfo;
 import com.intellij.openapi.util.io.win32.IdeaWin32;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.impl.local.LocalFileSystemBase;
@@ -60,8 +59,7 @@ public class Win32LocalFileSystem extends LocalFileSystemBase {
 
   @Override
   public FileAttributes getAttributes(@NotNull VirtualFile file) {
-    final FileInfo fileInfo = myFsCache.getInfo(file);
-    return fileInfo != null ? fileInfo.toFileAttributes() : null;
+    return myFsCache.getAttributes(file);
   }
 
   @NotNull

From 8a5fe9a453e5fe40b254dea71e92b497538e8dd3 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 14:07:06 +0400
Subject: [PATCH 105/354] notnull

---
 .../src/com/intellij/openapi/util/JDOMUtil.java     |  2 +-
 .../util/xmlb/AbstractCollectionBinding.java        |  3 ++-
 .../intellij/util/xmlb/AccessorBindingWrapper.java  |  3 ++-
 .../com/intellij/util/xmlb/AttributeBinding.java    |  3 ++-
 .../src/com/intellij/util/xmlb/BeanBinding.java     | 11 ++++++++---
 .../util/src/com/intellij/util/xmlb/Binding.java    |  3 ++-
 .../com/intellij/util/xmlb/JDOMElementBinding.java  |  3 ++-
 .../util/src/com/intellij/util/xmlb/MapBinding.java |  3 ++-
 .../com/intellij/util/xmlb/OptionTagBinding.java    |  3 ++-
 .../intellij/util/xmlb/PrimitiveValueBinding.java   |  3 ++-
 .../util/src/com/intellij/util/xmlb/TagBinding.java |  3 ++-
 .../com/intellij/util/xmlb/TagBindingWrapper.java   |  3 ++-
 .../src/com/intellij/util/xmlb/TextBinding.java     |  3 ++-
 .../src/com/intellij/util/xmlb/XmlSerializer.java   | 13 ++++++-------
 14 files changed, 37 insertions(+), 22 deletions(-)

diff --git a/platform/util/src/com/intellij/openapi/util/JDOMUtil.java b/platform/util/src/com/intellij/openapi/util/JDOMUtil.java
index 2f3824c93b4c..e2e017ac2466 100644
--- a/platform/util/src/com/intellij/openapi/util/JDOMUtil.java
+++ b/platform/util/src/com/intellij/openapi/util/JDOMUtil.java
@@ -136,7 +136,7 @@ public class JDOMUtil {
 
   @SuppressWarnings({"unchecked"})
   @NotNull
-  public static Object[] getChildNodesWithAttrs(final Element e) {
+  public static Object[] getChildNodesWithAttrs(@NotNull Element e) {
     ArrayList<Object> result = new ArrayList<Object>();
     result.addAll(e.getContent());
     result.addAll(e.getAttributes());
diff --git a/platform/util/src/com/intellij/util/xmlb/AbstractCollectionBinding.java b/platform/util/src/com/intellij/util/xmlb/AbstractCollectionBinding.java
index cf6db68d2dab..82ffb64e5b19 100644
--- a/platform/util/src/com/intellij/util/xmlb/AbstractCollectionBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/AbstractCollectionBinding.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.util.JDOMUtil;
 import com.intellij.util.xmlb.annotations.AbstractCollection;
 import org.jdom.Content;
 import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
@@ -130,7 +131,7 @@ abstract class AbstractCollectionBinding implements Binding {
     }
   }
 
-  public Object deserialize(Object o, Object... nodes) {
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     Collection result;
 
     if (getTagName(o) != null) {
diff --git a/platform/util/src/com/intellij/util/xmlb/AccessorBindingWrapper.java b/platform/util/src/com/intellij/util/xmlb/AccessorBindingWrapper.java
index 01daa631b141..75a5a28c8d93 100644
--- a/platform/util/src/com/intellij/util/xmlb/AccessorBindingWrapper.java
+++ b/platform/util/src/com/intellij/util/xmlb/AccessorBindingWrapper.java
@@ -16,6 +16,7 @@
 
 package com.intellij.util.xmlb;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 class AccessorBindingWrapper implements Binding {
@@ -33,7 +34,7 @@ class AccessorBindingWrapper implements Binding {
   }
 
   @Nullable
-  public Object deserialize(Object context, Object... nodes) {
+  public Object deserialize(Object context, @NotNull Object... nodes) {
     myAccessor.write(context, myBinding.deserialize(myAccessor.read(context), nodes));
     return context;
   }
diff --git a/platform/util/src/com/intellij/util/xmlb/AttributeBinding.java b/platform/util/src/com/intellij/util/xmlb/AttributeBinding.java
index 753db1a08dd5..1833947df827 100644
--- a/platform/util/src/com/intellij/util/xmlb/AttributeBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/AttributeBinding.java
@@ -19,6 +19,7 @@ package com.intellij.util.xmlb;
 import com.intellij.util.xmlb.annotations.Attribute;
 import org.jdom.Content;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 public class AttributeBinding implements Binding {
@@ -39,7 +40,7 @@ public class AttributeBinding implements Binding {
   }
 
   @Nullable
-  public Object deserialize(Object context, Object... nodes) {
+  public Object deserialize(Object context, @NotNull Object... nodes) {
     assert nodes.length == 1;
     Object node = nodes[0];
     assert isBoundTo(node);
diff --git a/platform/util/src/com/intellij/util/xmlb/BeanBinding.java b/platform/util/src/com/intellij/util/xmlb/BeanBinding.java
index a40a40ed6e3e..0f3433342385 100644
--- a/platform/util/src/com/intellij/util/xmlb/BeanBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/BeanBinding.java
@@ -60,6 +60,7 @@ class BeanBinding implements Binding {
     assert !StringUtil.isEmptyOrSpaces(myTagName) : "Bean name is empty: " + beanClass;
   }
 
+  @Override
   public void init() {
     initPropertyBindings(myBeanClass);
   }
@@ -72,6 +73,7 @@ class BeanBinding implements Binding {
     }
   }
 
+  @Override
   public Object serialize(Object o, Object context, SerializationFilter filter) {
     Element element = new Element(myTagName);
 
@@ -112,15 +114,16 @@ class BeanBinding implements Binding {
     }
   }
 
-  public void deserializeInto(final Object bean, final Element element) {
+  public void deserializeInto(final Object bean, @NotNull Element element) {
     _deserializeInto(bean, element);
   }
 
-  public Object deserialize(Object o, Object... nodes) {
+  @Override
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     return _deserializeInto(instantiateBean(), nodes);
   }
 
-  private Object _deserializeInto(final Object result, final Object... aNodes) {
+  private Object _deserializeInto(final Object result, @NotNull Object... aNodes) {
     List<Object> nodes = new ArrayList<Object>();
     for (Object aNode : aNodes) {
       if (XmlSerializerImpl.isIgnoredNode(aNode)) continue;
@@ -181,10 +184,12 @@ class BeanBinding implements Binding {
     return result;
   }
 
+  @Override
   public boolean isBoundTo(Object node) {
     return node instanceof Element && ((Element)node).getName().equals(myTagName);
   }
 
+  @Override
   public Class getBoundNodeType() {
     return Element.class;
   }
diff --git a/platform/util/src/com/intellij/util/xmlb/Binding.java b/platform/util/src/com/intellij/util/xmlb/Binding.java
index 841b45f3094f..53e77dc54bb4 100644
--- a/platform/util/src/com/intellij/util/xmlb/Binding.java
+++ b/platform/util/src/com/intellij/util/xmlb/Binding.java
@@ -15,13 +15,14 @@
  */
 package com.intellij.util.xmlb;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 interface Binding {
   Object serialize(Object o, @Nullable Object context, SerializationFilter filter);
 
   @Nullable
-  Object deserialize(Object context, Object... nodes);
+  Object deserialize(Object context, @NotNull Object... nodes);
 
   boolean isBoundTo(Object node);
 
diff --git a/platform/util/src/com/intellij/util/xmlb/JDOMElementBinding.java b/platform/util/src/com/intellij/util/xmlb/JDOMElementBinding.java
index 5d2f59fdc4a7..2c239b9e56ff 100644
--- a/platform/util/src/com/intellij/util/xmlb/JDOMElementBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/JDOMElementBinding.java
@@ -18,6 +18,7 @@ package com.intellij.util.xmlb;
 
 import com.intellij.util.xmlb.annotations.Tag;
 import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -57,7 +58,7 @@ class JDOMElementBinding implements Binding {
   }
 
   @Nullable
-  public Object deserialize(Object context, Object... nodes) {
+  public Object deserialize(Object context, @NotNull Object... nodes) {
     Element[] result = new Element[nodes.length];
 
     System.arraycopy(nodes, 0, result, 0, nodes.length);
diff --git a/platform/util/src/com/intellij/util/xmlb/MapBinding.java b/platform/util/src/com/intellij/util/xmlb/MapBinding.java
index 04435889b525..74be73e3ea7c 100644
--- a/platform/util/src/com/intellij/util/xmlb/MapBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/MapBinding.java
@@ -23,6 +23,7 @@ import org.jdom.Attribute;
 import org.jdom.Content;
 import org.jdom.Element;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -134,7 +135,7 @@ class MapBinding implements Binding {
     return myMapAnnotation == null ? KEY : myMapAnnotation.keyAttributeName();
   }
 
-  public Object deserialize(Object o, Object... nodes) {
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     Map map = (Map)o;
     map.clear();
 
diff --git a/platform/util/src/com/intellij/util/xmlb/OptionTagBinding.java b/platform/util/src/com/intellij/util/xmlb/OptionTagBinding.java
index ad7bd15e67f9..2995bbcf4cdc 100644
--- a/platform/util/src/com/intellij/util/xmlb/OptionTagBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/OptionTagBinding.java
@@ -25,6 +25,7 @@ import org.jdom.Content;
 import org.jdom.Element;
 import org.jdom.Text;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -80,7 +81,7 @@ class OptionTagBinding implements Binding {
     return targetElement;
   }
 
-  public Object deserialize(Object o, Object... nodes) {
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     if (nodes.length > 1) {
       LOG.info("Duplicate options for " + o + " will be ignored");
     }
diff --git a/platform/util/src/com/intellij/util/xmlb/PrimitiveValueBinding.java b/platform/util/src/com/intellij/util/xmlb/PrimitiveValueBinding.java
index 61e934cb0214..7a0c23ac681b 100644
--- a/platform/util/src/com/intellij/util/xmlb/PrimitiveValueBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/PrimitiveValueBinding.java
@@ -18,6 +18,7 @@ package com.intellij.util.xmlb;
 
 import com.intellij.openapi.util.JDOMUtil;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 class PrimitiveValueBinding implements Binding {
@@ -33,7 +34,7 @@ class PrimitiveValueBinding implements Binding {
   }
 
   @Nullable
-  public Object deserialize(Object o, Object... nodes) {
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     assert nodes != null;
 
     if (nodes.length == 0) {
diff --git a/platform/util/src/com/intellij/util/xmlb/TagBinding.java b/platform/util/src/com/intellij/util/xmlb/TagBinding.java
index 87ae313d2ab1..087f24264c7a 100644
--- a/platform/util/src/com/intellij/util/xmlb/TagBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/TagBinding.java
@@ -22,6 +22,7 @@ import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.xmlb.annotations.Tag;
 import org.jdom.Element;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -53,7 +54,7 @@ class TagBinding implements Binding {
     return v;
   }
 
-  public Object deserialize(Object o, Object... nodes) {
+  public Object deserialize(Object o, @NotNull Object... nodes) {
     assert nodes.length > 0;
     Object[] children;
     if (nodes.length == 1) {
diff --git a/platform/util/src/com/intellij/util/xmlb/TagBindingWrapper.java b/platform/util/src/com/intellij/util/xmlb/TagBindingWrapper.java
index 5b414b894258..6fc29fe43c81 100644
--- a/platform/util/src/com/intellij/util/xmlb/TagBindingWrapper.java
+++ b/platform/util/src/com/intellij/util/xmlb/TagBindingWrapper.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.util.JDOMUtil;
 import org.jdom.Content;
 import org.jdom.Element;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 
 //todo: merge with option tag binding
 class TagBindingWrapper implements Binding {
@@ -51,7 +52,7 @@ class TagBindingWrapper implements Binding {
     return e;
   }
 
-  public Object deserialize(Object context, Object... nodes) {
+  public Object deserialize(Object context, @NotNull Object... nodes) {
     assert nodes.length == 1;
 
     Element e = (Element)nodes[0];
diff --git a/platform/util/src/com/intellij/util/xmlb/TextBinding.java b/platform/util/src/com/intellij/util/xmlb/TextBinding.java
index ff6bed258705..9419e5b0b9d2 100644
--- a/platform/util/src/com/intellij/util/xmlb/TextBinding.java
+++ b/platform/util/src/com/intellij/util/xmlb/TextBinding.java
@@ -18,6 +18,7 @@ package com.intellij.util.xmlb;
 
 import org.jdom.Content;
 import org.jdom.Text;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 public class TextBinding implements Binding {
@@ -36,7 +37,7 @@ public class TextBinding implements Binding {
   }
 
   @Nullable
-  public Object deserialize(Object context, Object... nodes) {
+  public Object deserialize(Object context, @NotNull Object... nodes) {
     assert nodes.length == 1;
     Object node = nodes[0];
     assert isBoundTo(node);
diff --git a/platform/util/src/com/intellij/util/xmlb/XmlSerializer.java b/platform/util/src/com/intellij/util/xmlb/XmlSerializer.java
index 6a2e264aa0d4..7b78227b0e50 100644
--- a/platform/util/src/com/intellij/util/xmlb/XmlSerializer.java
+++ b/platform/util/src/com/intellij/util/xmlb/XmlSerializer.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.util.JDOMUtil;
 import org.jdom.Document;
 import org.jdom.Element;
 import org.jdom.JDOMException;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
@@ -28,6 +29,7 @@ import java.net.URL;
 
 public class XmlSerializer {
   private static final SerializationFilter TRUE_FILTER = new SerializationFilter() {
+    @Override
     public boolean accepts(Accessor accessor, Object bean) {
       return true;
     }
@@ -54,8 +56,7 @@ public class XmlSerializer {
   @SuppressWarnings({"unchecked"})
   public static <T> T deserialize(Element element, Class<T> aClass) throws XmlSerializationException {
     try {
-      XmlSerializerImpl serializer = new XmlSerializerImpl(TRUE_FILTER);
-      return (T)serializer.getBinding(aClass).deserialize(null, element);
+      return (T)XmlSerializerImpl.getBinding(aClass).deserialize(null, element);
     }
     catch (XmlSerializationException e) {
       throw e;
@@ -91,10 +92,9 @@ public class XmlSerializer {
     }
   }
 
-  public static void deserializeInto(final Object bean, final Element element) {
+  public static void deserializeInto(@NotNull Object bean, @NotNull Element element) {
     try {
-      XmlSerializerImpl serializer = new XmlSerializerImpl(TRUE_FILTER);
-      final Binding binding = serializer.getBinding(bean.getClass());
+      final Binding binding = XmlSerializerImpl.getBinding(bean.getClass());
       assert binding instanceof BeanBinding;
 
       ((BeanBinding)binding).deserializeInto(bean, element);
@@ -116,8 +116,7 @@ public class XmlSerializer {
       filter = TRUE_FILTER;
     }
     try {
-      XmlSerializerImpl serializer = new XmlSerializerImpl(filter);
-      final Binding binding = serializer.getBinding(bean.getClass());
+      final Binding binding = XmlSerializerImpl.getBinding(bean.getClass());
       assert binding instanceof BeanBinding;
 
       ((BeanBinding)binding).serializeInto(bean, element, filter);

From 19d062cae68e42fdfc66436659fd170aa2410dc2 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 14:21:14 +0400
Subject: [PATCH 106/354] get rid of JDOM duplicates in memory

---
 .../com/intellij/codeInspection/ex/InspectionProfileImpl.java  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
index 103560466ea5..b60b58736eb3 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
@@ -261,7 +261,8 @@ public class InspectionProfileImpl extends ProfileEx implements ModifiableModel,
 
     StringInterner interner = new StringInterner();
     for (final Object o : element.getChildren(INSPECTION_TOOL_TAG)) {
-      Element toolElement = (Element)o;
+      // make clone to avoid retaining memory via o.parent pointers
+      Element toolElement = (Element)((Element)o).clone();
       JDOMUtil.internElement(toolElement, interner);
 
       String toolClassName = toolElement.getAttributeValue(CLASS_TAG);

From 6cc23db482c654092df4a0346e48dc57a03507e8 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 14:31:19 +0400
Subject: [PATCH 107/354] cleanup

---
 .../openapi/extensions/impl/AreaPicoContainerImpl.java      | 1 -
 .../util/src/com/intellij/util/xmlb/XmlSerializerImpl.java  | 6 +++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/platform/extensions/src/com/intellij/openapi/extensions/impl/AreaPicoContainerImpl.java b/platform/extensions/src/com/intellij/openapi/extensions/impl/AreaPicoContainerImpl.java
index 14e81e91e081..099421ab6122 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/impl/AreaPicoContainerImpl.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/impl/AreaPicoContainerImpl.java
@@ -26,7 +26,6 @@ import org.picocontainer.alternatives.AbstractDelegatingMutablePicoContainer;
 /**
  * @author Alexander Kireyev
  */
-@SuppressWarnings({"unchecked"})
 class AreaPicoContainerImpl extends AbstractDelegatingMutablePicoContainer implements AreaPicoContainer {
   private final AreaInstance myAreaInstance;
 
diff --git a/platform/util/src/com/intellij/util/xmlb/XmlSerializerImpl.java b/platform/util/src/com/intellij/util/xmlb/XmlSerializerImpl.java
index 2a319eb07638..49959390248f 100644
--- a/platform/util/src/com/intellij/util/xmlb/XmlSerializerImpl.java
+++ b/platform/util/src/com/intellij/util/xmlb/XmlSerializerImpl.java
@@ -61,7 +61,7 @@ class XmlSerializerImpl {
     if (type instanceof Class) {
       return _getClassBinding((Class<?>)type, type, accessor);
     }
-    else if (type instanceof ParameterizedType) {
+    if (type instanceof ParameterizedType) {
       ParameterizedType parameterizedType = (ParameterizedType)type;
       Type rawType = parameterizedType.getRawType();
       assert rawType instanceof Class;
@@ -154,7 +154,7 @@ class XmlSerializerImpl {
   }
 
   public static boolean isIgnoredNode(final Object child) {
-    if (child instanceof Text && ((Text)child).getValue().trim().length() == 0) {
+    if (child instanceof Text && ((Text)child).getValue().trim().isEmpty()) {
       return true;
     }
     if (child instanceof Comment) {
@@ -163,7 +163,7 @@ class XmlSerializerImpl {
     if (child instanceof Attribute) {
       Attribute attr = (Attribute)child;
       final String namespaceURI = attr.getNamespaceURI();
-      if (namespaceURI != null && namespaceURI.length() > 0) return true;
+      if (namespaceURI != null && !namespaceURI.isEmpty()) return true;
     }
 
     return false;

From 2f2e923fbfdbea42f7c63e485534ad1bf8292e2b Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Mon, 25 Feb 2013 14:38:08 +0400
Subject: [PATCH 108/354] project templates: choosing app server

---
 .../openapi/module/BasePackageParameterFactory.java       | 2 +-
 .../projectWizard/ProjectTemplateParameterFactory.java    | 1 +
 .../src/com/intellij/execution/impl/RunManagerImpl.java   | 8 +++++++-
 .../src/com/intellij/ui/CollectionComboBoxModel.java      | 4 ++++
 4 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java b/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java
index e2f3308f7ef2..809f65d80d7d 100644
--- a/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java
+++ b/java/java-impl/src/com/intellij/openapi/module/BasePackageParameterFactory.java
@@ -60,7 +60,7 @@ public class BasePackageParameterFactory extends ProjectTemplateParameterFactory
 
       @Override
       public String getLabel() {
-        return "Base package:";
+        return "Base \u001Bpackage:";
       }
 
       @Override
diff --git a/platform/lang-api/src/com/intellij/ide/util/projectWizard/ProjectTemplateParameterFactory.java b/platform/lang-api/src/com/intellij/ide/util/projectWizard/ProjectTemplateParameterFactory.java
index 408c51870736..1a9026daf136 100644
--- a/platform/lang-api/src/com/intellij/ide/util/projectWizard/ProjectTemplateParameterFactory.java
+++ b/platform/lang-api/src/com/intellij/ide/util/projectWizard/ProjectTemplateParameterFactory.java
@@ -30,6 +30,7 @@ public abstract class ProjectTemplateParameterFactory {
   // standard ids
   public static final String IJ_BASE_PACKAGE = "IJ_BASE_PACKAGE";
   public static final String IJ_PROJECT_NAME = "IJ_PROJECT_NAME";
+  public static final String IJ_APPLICATION_SERVER = "IJ_APPLICATION_SERVER";
 
   public abstract String getParameterId();
 
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
index 58ae0b7e4d9a..876a4303f50c 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
@@ -19,6 +19,7 @@ package com.intellij.execution.impl;
 import com.intellij.execution.*;
 import com.intellij.execution.configurations.*;
 import com.intellij.ide.util.PropertiesComponent;
+import com.intellij.ide.util.projectWizard.ProjectTemplateComponent;
 import com.intellij.openapi.components.ProjectComponent;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.Project;
@@ -39,7 +40,7 @@ import javax.swing.*;
 import java.util.*;
 
 
-public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, ProjectComponent {
+public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, ProjectComponent, ProjectTemplateComponent {
   private final Project myProject;
 
   private final Map<String, ConfigurationType> myTypesByName = new LinkedHashMap<String, ConfigurationType>();
@@ -1140,4 +1141,9 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
       myProviderKeysMap.put(id.toString(), id);
     }
   }
+
+  @Override
+  public String getStorageFile() {
+    return "workspace.xml";
+  }
 }
diff --git a/platform/platform-api/src/com/intellij/ui/CollectionComboBoxModel.java b/platform/platform-api/src/com/intellij/ui/CollectionComboBoxModel.java
index 162bb82a1e42..51703470e7cf 100644
--- a/platform/platform-api/src/com/intellij/ui/CollectionComboBoxModel.java
+++ b/platform/platform-api/src/com/intellij/ui/CollectionComboBoxModel.java
@@ -32,6 +32,10 @@ public class CollectionComboBoxModel extends AbstractCollectionComboBoxModel {
     myItems = Collections.unmodifiableList(items);
   }
 
+  public CollectionComboBoxModel(List items) {
+    super(items.isEmpty() ? null : items.get(0));
+    myItems = items;
+  }
 
   @NotNull
   final protected List getItems() {

From fe8cc8426951a10029de88ceb296ffa24ace911a Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Mon, 25 Feb 2013 14:51:17 +0400
Subject: [PATCH 109/354] IDEA-101631 Updating Maven snapshots with sources
 does not synchronize sources to latest when navigating to class

---
 .../intellij/openapi/util/text/StringUtil.java   | 16 ++++++++++++++++
 .../idea/maven/model/MavenArtifact.java          |  6 +++---
 .../maven/importing/MavenRootModelAdapter.java   | 13 +++++++++++--
 3 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/platform/util/src/com/intellij/openapi/util/text/StringUtil.java b/platform/util/src/com/intellij/openapi/util/text/StringUtil.java
index 2bf2eaf0dd4b..2da159165c07 100644
--- a/platform/util/src/com/intellij/openapi/util/text/StringUtil.java
+++ b/platform/util/src/com/intellij/openapi/util/text/StringUtil.java
@@ -801,6 +801,22 @@ public class StringUtil extends StringUtilRt {
     return testee.startsWith(firstPrefix) && testee.regionMatches(l1, secondPrefix, 0, l2);
   }
 
+  /**
+   * Equivalent to testee.startsWith(firstPrefix + secondPrefix + thirdPrefix) but avoids creating an object for concatenation.
+   */
+  public static boolean startsWithConcatenationOf(@NotNull String testee,
+                                                  @NotNull String firstPrefix,
+                                                  @NotNull String secondPrefix,
+                                                  @NotNull String thirdPrefix) {
+    int l1 = firstPrefix.length();
+    int l2 = secondPrefix.length();
+    int l3 = thirdPrefix.length();
+    if (testee.length() < l1 + l2 + l3) return false;
+    return testee.startsWith(firstPrefix)
+           && testee.regionMatches(l1, secondPrefix, 0, l2)
+           && testee.regionMatches(l1 + l2, thirdPrefix, 0, l3);
+  }
+
   @NotNull
   public static String trimEnd(@NotNull String s, @NonNls @NotNull String suffix) {
     if (s.endsWith(suffix)) {
diff --git a/plugins/maven/maven-server-api/src/org/jetbrains/idea/maven/model/MavenArtifact.java b/plugins/maven/maven-server-api/src/org/jetbrains/idea/maven/model/MavenArtifact.java
index 829a8ffcb352..75ad374423de 100644
--- a/plugins/maven/maven-server-api/src/org/jetbrains/idea/maven/model/MavenArtifact.java
+++ b/plugins/maven/maven-server-api/src/org/jetbrains/idea/maven/model/MavenArtifact.java
@@ -140,9 +140,9 @@ public class MavenArtifact implements Serializable {
     return getRelativePathForExtraArtifact(null, null);
   }
 
-  public String getFileNameWithBaseVersion() {
+  public String getFileNameWithBaseVersion(@Nullable String extraArtifactClassifier, @Nullable String customExtension) {
     StringBuilder res = new StringBuilder();
-    appendFileName(res, null, null);
+    appendFileName(res, extraArtifactClassifier, customExtension);
     return res.toString();
   }
 
@@ -166,7 +166,7 @@ public class MavenArtifact implements Serializable {
     result.append('/');
     result.append(myArtifactId);
     result.append('/');
-    result.append(myVersion);
+    result.append(myBaseVersion);
     result.append('/');
 
     appendFileName(result, extraArtifactClassifier, customExtension);
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
index 27c8f5cad1fb..6aaf850d5d28 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
@@ -334,8 +334,17 @@ public class MavenRootModelAdapter {
     library.addRoot(newUrl, type);
   }
 
-  private static boolean isRepositoryUrl(MavenArtifact artifact, String url, String classifier, String extension) {
-    return url.endsWith(artifact.getRelativePathForExtraArtifact(classifier, extension) + JarFileSystem.JAR_SEPARATOR);
+  private static boolean isRepositoryUrl(MavenArtifact artifact, String url, @Nullable String classifier, @Nullable String extension) {
+    if (!url.contains(artifact.getGroupId() + '/' + artifact.getArtifactId() + '/' + artifact.getBaseVersion() + '/' + artifact.getArtifactId() + '-')) {
+      return false;
+    }
+
+    String fileName = artifact.getFileNameWithBaseVersion(classifier, extension);
+    assert StringUtil.startsWithConcatenationOf(fileName, artifact.getArtifactId(), "-", artifact.getVersion());
+
+    String suffix = fileName.substring(artifact.getArtifactId().length() + 1 + artifact.getVersion().length());
+
+    return StringUtil.trimEnd(url, "!/").endsWith(suffix);
   }
 
   public static boolean isChangedByUser(Library library) {

From a9d8a9c7bcf5ba0e771882b810a546c6f6aeb33b Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Mon, 25 Feb 2013 14:59:14 +0400
Subject: [PATCH 110/354] CR-IC-199 Avoid memory leak in 'editor tabs: none'
 mode

Revert 'reuse editor' change as it breaks 'split editor' functionality
---
 .../impl/text/TextEditorComponent.java           | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
index 960e977d294e..89129280b1f8 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
@@ -23,10 +23,7 @@ import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.editor.event.DocumentAdapter;
-import com.intellij.openapi.editor.event.DocumentEvent;
-import com.intellij.openapi.editor.event.EditorMouseEvent;
-import com.intellij.openapi.editor.event.EditorMouseEventArea;
+import com.intellij.openapi.editor.event.*;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.editor.ex.EditorMarkupModel;
 import com.intellij.openapi.editor.highlighter.EditorHighlighter;
@@ -62,7 +59,7 @@ import java.beans.PropertyChangeListener;
  * @author Anton Katilin
  * @author Vladimir Kondratyev
  */
-class TextEditorComponent extends JBLoadingPanel implements DataProvider {
+class TextEditorComponent extends JBLoadingPanel implements DataProvider{
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.fileEditor.impl.text.TextEditorComponent");
 
   private final Project myProject;
@@ -163,19 +160,14 @@ class TextEditorComponent extends JBLoadingPanel implements DataProvider {
   Editor getEditor(){
     return myEditor;
   }
-  
+
   /**
    * @return created editor. This editor should be released by {@link #disposeEditor(Editor) }
    * method.
    */
   @NotNull
   private Editor createEditor(){
-    EditorFactory editorFactory = EditorFactory.getInstance();
-    Editor[] editors = editorFactory.getEditors(myDocument);
-    if (editors.length == 1) {
-      return editors[0];
-    }
-    final Editor editor = editorFactory.createEditor(myDocument, myProject);
+    Editor editor = EditorFactory.getInstance().createEditor(myDocument, myProject);
     ((EditorMarkupModel) editor.getMarkupModel()).setErrorStripeVisible(true);
     EditorHighlighter highlighter = EditorHighlighterFactory.getInstance().createEditorHighlighter(myFile, EditorColorsManager.getInstance().getGlobalScheme(), myProject);
     ((EditorEx) editor).setHighlighter(highlighter);

From 04c24901c2b3afcba74758a0575c6c843196ab05 Mon Sep 17 00:00:00 2001
From: Fedor Korotkov <fedor.korotkov@jetbrains.com>
Date: Mon, 25 Feb 2013 15:03:58 +0400
Subject: [PATCH 111/354] WEB-6803 HTML microdata: properties of item are taken
 from the wrong scope in case of nested scopes

---
 ...MicrodataAttributeDescriptorsProvider.java |  5 +++--
 .../html/MicrodataCompletionTest.java         | 21 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
index 2279ca785aee..319ae1a9d5b4 100644
--- a/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
+++ b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
@@ -94,9 +94,10 @@ public class MicrodataAttributeDescriptorsProvider implements XmlAttributeDescri
 
   private static class MicrodataPropertyAttributeDescriptor extends AnyXmlAttributeDescriptor {
 
+    @NotNull
     private final XmlTag myContext;
 
-    public MicrodataPropertyAttributeDescriptor(XmlTag context) {
+    public MicrodataPropertyAttributeDescriptor(@NotNull XmlTag context) {
       super(ITEM_PROP);
       myContext = context;
     }
@@ -114,7 +115,7 @@ public class MicrodataAttributeDescriptorsProvider implements XmlAttributeDescri
 
     @Override
     public String[] getEnumeratedValues() {
-      final XmlTag scopeParent = findScopeTag(myContext);
+      final XmlTag scopeParent = findScopeTag(myContext.getParentTag());
       return scopeParent != null ? findProperties(scopeParent) : super.getEnumeratedValues();
     }
 
diff --git a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
index 988fe496f109..5b40884bc054 100644
--- a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
+++ b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
@@ -151,4 +151,25 @@ public class MicrodataCompletionTest extends CodeInsightFixtureTestCase {
                  "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address"
     );
   }
+
+  public void testPropValueNestedScopes() throws Throwable {
+    final VirtualFile personFile = myFixture.copyFileToProject("Person.html");
+    final VirtualFile addressFile = myFixture.copyFileToProject("Address.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Person", personFile.getPath());
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Address", addressFile.getPath());
+      }
+    });
+    doTestInHtml("<div itemscope itemtype=\"http://data-vocabulary.org/Person\">\n" +
+                 "    My name is <span itemprop=\"name\">Smith</span>\n" +
+                 "    <span itemprop=\"<caret>\" itemscope itemtype=\"http://data-vocabulary.org/Address\">\n" +
+                 "        <span itemprop=\"locality\">Albuquerque</span>\n" +
+                 "        <span itemprop=\"region\">NM</span>\n" +
+                 "    </span>\n" +
+                 "</div>",
+                 "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address"
+    );
+  }
 }

From 268bcb9cb71d9bd28a25d5b2670b94b868e1d9a8 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Mon, 25 Feb 2013 12:27:13 +0100
Subject: [PATCH 112/354] Default constructor restored, sorry

---
 platform/util-rt/src/com/intellij/util/containers/Stack.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/platform/util-rt/src/com/intellij/util/containers/Stack.java b/platform/util-rt/src/com/intellij/util/containers/Stack.java
index 966b89010725..7df0c93a9e55 100644
--- a/platform/util-rt/src/com/intellij/util/containers/Stack.java
+++ b/platform/util-rt/src/com/intellij/util/containers/Stack.java
@@ -26,6 +26,8 @@ import java.util.*;
  * @author max
  */
 public class Stack<T> extends ArrayList<T> {
+  public Stack() { }
+
   public Stack(int initialCapacity) {
     super(initialCapacity);
   }

From 24a0677ccedf7d7a9d4adede9a7d730a8c47da9f Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 12:29:24 +0100
Subject: [PATCH 113/354] NPE

---
 .../codeInspection/nullable/NullableStuffInspection.java    | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
index eafc30013451..4343faee75a7 100644
--- a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
@@ -402,8 +402,10 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
 
   private static LocalQuickFix createChangeDefaultNotNullFix(NullableNotNullManager nullableManager, PsiModifierListOwner modifierListOwner) {
     final PsiAnnotation annotation = AnnotationUtil.findAnnotation(modifierListOwner, nullableManager.getNotNulls());
-    LOG.assertTrue(annotation != null);
-    return new ChangeNullableDefaultsFix(annotation.getQualifiedName(), null, nullableManager);
+    if (annotation != null) {
+      return new ChangeNullableDefaultsFix(annotation.getQualifiedName(), null, nullableManager);
+    }
+    return null;
   }
 
   protected AnnotateMethodFix createAnnotateMethodFix(final String defaultNotNull, final String[] annotationsToRemove) {

From 28804faa24ae9375bc69cace464b4cc7b7f234ad Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 12:49:51 +0100
Subject: [PATCH 114/354] selected tear line is too bright

---
 colorSchemes/src/colorSchemes/Darcula.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index b6556d6be8a7..b1b86397c116 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -36,7 +36,7 @@
     <option name="REMOTE_HOST_MAPPED_BACKGROUND_KEY" value="164716" />
     <option name="RIGHT_MARGIN_COLOR" value="4d4d4d" />
     <option name="SELECTED_INDENT_GUIDE" value="505050" />
-    <option name="SELECTED_TEARLINE_COLOR" value="ffffff" />
+    <option name="SELECTED_TEARLINE_COLOR" value="787878" />
     <option name="SELECTION_BACKGROUND" value="214283" />
     <option name="SELECTION_FOREGROUND" value="" />
     <option name="TEARLINE_COLOR" value="555555" />

From 3477f4eafa146c1a981ade5ce0e3e18a67bedf69 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 12:54:18 +0100
Subject: [PATCH 115/354] xml attribute names are too bright

---
 colorSchemes/src/colorSchemes/Darcula.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index b1b86397c116..5debddc000c6 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -1616,7 +1616,7 @@
     </option>
     <option name="XML_ATTRIBUTE_NAME">
       <value>
-        <option name="FOREGROUND" value="d0d0ff" />
+        <option name="FOREGROUND" value="bababa" />
       </value>
     </option>
     <option name="XML_ATTRIBUTE_VALUE">

From ef600f8d8ac0afb8e0d86fe7bf0d6b082249c0ee Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 13:12:58 +0100
Subject: [PATCH 116/354] new hierarchy icons for Darcula nad Retina

---
 platform/icons/src/hierarchy/base@2x.png          | Bin 0 -> 635 bytes
 platform/icons/src/hierarchy/callee@2x.png        | Bin 0 -> 469 bytes
 platform/icons/src/hierarchy/callee@2x_dark.png   | Bin 0 -> 472 bytes
 platform/icons/src/hierarchy/caller@2x.png        | Bin 0 -> 520 bytes
 platform/icons/src/hierarchy/caller@2x_dark.png   | Bin 0 -> 511 bytes
 platform/icons/src/hierarchy/class@2x.png         | Bin 0 -> 698 bytes
 platform/icons/src/hierarchy/class@2x_dark.png    | Bin 0 -> 704 bytes
 platform/icons/src/hierarchy/methodDefined@2x.png | Bin 0 -> 364 bytes
 .../icons/src/hierarchy/methodNotDefined@2x.png   | Bin 0 -> 161 bytes
 .../icons/src/hierarchy/shouldDefineMethod@2x.png | Bin 0 -> 350 bytes
 platform/icons/src/hierarchy/subtypes@2x.png      | Bin 0 -> 469 bytes
 platform/icons/src/hierarchy/subtypes@2x_dark.png | Bin 0 -> 472 bytes
 platform/icons/src/hierarchy/supertypes@2x.png    | Bin 0 -> 517 bytes
 .../icons/src/hierarchy/supertypes@2x_dark.png    | Bin 0 -> 511 bytes
 14 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/hierarchy/base@2x.png
 create mode 100644 platform/icons/src/hierarchy/callee@2x.png
 create mode 100644 platform/icons/src/hierarchy/callee@2x_dark.png
 create mode 100644 platform/icons/src/hierarchy/caller@2x.png
 create mode 100644 platform/icons/src/hierarchy/caller@2x_dark.png
 create mode 100644 platform/icons/src/hierarchy/class@2x.png
 create mode 100644 platform/icons/src/hierarchy/class@2x_dark.png
 create mode 100644 platform/icons/src/hierarchy/methodDefined@2x.png
 create mode 100644 platform/icons/src/hierarchy/methodNotDefined@2x.png
 create mode 100644 platform/icons/src/hierarchy/shouldDefineMethod@2x.png
 create mode 100644 platform/icons/src/hierarchy/subtypes@2x.png
 create mode 100644 platform/icons/src/hierarchy/subtypes@2x_dark.png
 create mode 100644 platform/icons/src/hierarchy/supertypes@2x.png
 create mode 100644 platform/icons/src/hierarchy/supertypes@2x_dark.png

diff --git a/platform/icons/src/hierarchy/base@2x.png b/platform/icons/src/hierarchy/base@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..0292f847071a9c3c0d765b775e9b6909c984d4bf
GIT binary patch
literal 635
zcmV->0)+jEP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!9Z5t%RCwC#m(5NaF%ZYcyY_xj9*K{D
z%B7V`d4;N?t&liz!YdAOT9Mv+=}Qz6sMM+lB;bXrCClz=&Dcp$nrw)jtlA!8X=E#s
zXMXw5cqSoIO8A$HECK#IfajktY<)D*Vs-d=^uii|j(=dI2yqAyLb$pkOBv6jz$Adp
zW!DAIqfitj&$1kbO4ux?N&!=IP=O%yAzJZ)G0L~w-R55f0D>wo7XgAkgh%;SyVG0{
zz}!l;69O)y5Uzv}Mgc0pc;nO@Vj%!oDwF!`Qda{gqm=T^Pi7Dk03~`eH9305yDp|9
zh<sEdP^sbTAJ2uo0_e@u^o9xyZK#AQ%plSb$7`)KVbzEl?XGkj$0&cyXYgz_0uT4`
zLe8@SdPxd*Nl%?y*L;^70lfV3OR_PCQ{_WY^$Mzh|Aa{KoVRY`*L)_xtFKp5Nm$1k
zh3E|+Zcq03)17dT&$^bX2_L`EpjgwHt+=ci;1R<2;va`Q!e|)PJ)+TH+<CVtjHh9p
z04n&mH*3Op8e*P^WeVg|!O!2W3#)OQ^>W=}&7L9A`JM6%<IeuZ%uYA~ko-=-Nemm2
z#~@k_^*$cFJ0<5c0rLCI>Ye-8`{_u{sNfgx8^YAbLO;pW2pTO~75wtUmar)xS~ZT1
zSJ^i`mNEGE1H0gr0G5xeuY)Y(A}_=|9;o@Fs;U9qIb-biBE3tO|BRLZbFBvf1^|;V
V?%K`}-7x?F002ovPDHLkV1hU_Bj*4B

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/callee@2x.png b/platform/icons/src/hierarchy/callee@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..302057bb466bf8016a62644e9d11aafcf82c177e
GIT binary patch
literal 469
zcmV;`0V@89P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzcS%G+RCwBA{Qv(y!$1PYQ3s4VU`RP&
zS*aaSile#@F%oMg3n{K;=U`=EW@g5#=I`IXB!vJ;4&WEy0Xl*WubQ7fe$mbWtZXa{
zoSgU_@bBM0+Bx7qFnIqF2;%>=i~>;n5{hG*rh$Lp5coq-4GkUehvDBJW`b&{S`I`-
zMZwvzS}*@|ak1l7|LxmPhQ-&!;pM=xWy`1-0{?(f@b3>nH8hKYr8lHNKC1=dXFz-a
zi0?wB6oA+ch~<E|g%mTHNG!VRfVc^2(Oo3*2SBV0#LZAOGzkHa!HrM{)MJr{i8Vs$
zCTco>kmbmZ_zzXfh~ya3a)Hm}-T#@HP%E^*|Nb-Z9iLBBE%(VX5v%?!xvq>vg#afv
zI|Ca#D~i~!pT7xaDHsTycL=L~qNCtHBNGE7GYgs+@!5+M{a79F>(?Kk0n8X;!~#<E
zV|T!BEC&20!2u-b$LfGTzyAVTK7TO8hy|qRA8i$nI$+cR009O7u#&{?b3tKm00000
LNkvXXu0mjfx%J7|

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/callee@2x_dark.png b/platform/icons/src/hierarchy/callee@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..f09e1d570724cde23ec47196d30f2240146bf2c1
GIT binary patch
literal 472
zcmV;}0Vn>6P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzdPzh<RCwC#mcL8GKorN{<?_SSf)3JA
zh5jGi+`0<l=#<6LQKi+*(Iu0ki)%L#r2j`j5uBWhNiKJNDQRu(k-LK&BIMwa@b3HG
zeezy%IU<CBzZ|3iXaN2dz~e<vOMH4aCb~IY6WU<Q14?P7CeL%D3K#+G?6wiYuhb;p
zsXYMCcOeX`0XXOO00fqoD@rVEwxH;*s>fE}0Y0w)Q)(;%FyM?THMQ;oaU3u255As6
zs})r0r_%)9_l}qQKomtaR)Av*I8$n@wcw+3Qasru+9%p8+N7L1MC+mLLmO^Qayo`v
z_Z8Z3zR=I&#dt&OqTQ4lD-|db4@!V*$^61MD6hjh0aS~xLWojJR$$D&g8u!ppw9Xa
zE$0II-bCv!H_E!w_|f?h(W*eW9e^KrYrZteAUcb*%JuRvmd0zhKoAEAb$|KvKQEJb
zDL|SsOh7k$y2B)14v<L_WCj2R@lpVm<#_U88$R7(65pJP8-NC2CcpqJF~nT^VW-Og
O0000<MNUMnLSTYhH_+1n

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/caller@2x.png b/platform/icons/src/hierarchy/caller@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..9deead781af43f35f6112449c82c8527089f7409
GIT binary patch
literal 520
zcmV+j0{8uiP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzs!2paRCwC#R<TM0K@gqIUUCWc5mAe@
z_Wpr38qhk8UtlF^&BflzFAyQU5NzTfSlHPp*cfb;h%vXbyUxXnnoI6>PdEZ{1H*E&
zGqZ2rEOX1W*04w^z=9<QkOOe$8S7^~%?oVGCY1&h$fQ)U$$HJ*#Q5&vHnRdyS#qJ|
z7N>0fNWkD#0!nGDDlXod0nG})xD&C_;Z%hX$_OAX-Wq`KBPHN7HX%q6jR4}}?E#26
z3CKow0HiRtATHh-0Ma3x<BSbaf=pnb(P(`6ZXV2yw`bse#5Df&dinOkqoq|Py<6F7
z8whAsZ_a}?@bfyIPWm}8d>g{xW$>*Jwfz9VST~-pyo7vSM2*5sf5Qo_p&W;modlIe
zT-)J(E8HK8i2*0&;F=`vlh#Nd!|!#{`{?0+o`i8yUwyK9JhZ$0HI@kgw_K##%@cj3
z#iUGi2Y$=->7I7Wr9_|6hYwpvm)S5-EIClABm+=NL1uSA6TQknu};~7Q~-khntCj=
z1fa$YpwTBo00;`X(I;aD<N_H`1VEwDC$l+_Kg)9f{}RBb00RKt3*z5d9VmtX0000<
KMNUMnLSTY_M&(HW

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/caller@2x_dark.png b/platform/icons/src/hierarchy/caller@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..1bf2383424db85bcd9ba3790b66d889926011d64
GIT binary patch
literal 511
zcmV<b0RaAqP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzp-DtRRCwC#mc35HFc8Pjb<#BAV_;{f
z5N`q#NG!1M1YMXAYn!k$v1DRoM`9~)QlSbVcAyod@!7_yQc%;xc0f@Xa?&Zv<?j6R
z|17seN(rkpQUlZg{}SNvx-V&iEX25wfD8%eqOe*2;y_z}f3{DuHBMe5f6arY=PtzJ
zDTC1)2jtwitD^cm%LS060fai4m|9%zf-zwPD5|#xh+|X@=u(U^<%mXrqI!D(meWAR
z)ENNI%p)kOw+2A92&K3bL*&3U3Pe$q=C*U|?G^Z#5{W;vKG}E*z=vMq(O^9^2+%wB
zhsiU^3p$;SHo1`(oQx+hdL4cH&GS}}G@CWt9S53zLB{`n5zS>yt()%bGTCV+HB7(v
z((f}fDd3d6xaN&tl(&@+)Aw!VgY4oqRtjMA@z&<v4&Qf9NhJVY%T=eFYIC^7P5J8|
zqlc>_>9v~Loatu_d*^r6DBw07@O?di5CSSY15(K=3=+$dBPa!s%-1wyUL}B-DS*bD
z3IPxVQe#fV3h)&wAQXT=V^00AxCW>J%Gj3x0|1Y(1OB-yyaxaP002ovPDHLkV1iqo
B;SB%)

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/class@2x.png b/platform/icons/src/hierarchy/class@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..fbf2ba08a0689edbae2dc0791183bb51e2a2338f
GIT binary patch
literal 698
zcmV;r0!96aP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!TuDShRCwCNS37SLK@gt3mwm`QL>uv_
z0#zy`egO>#QUxI+en1KuBuWwmN<@Xk4<JB86;NpM3nC@dfeKP10WmRW-|h}G=S227
zdyj?Nu-0f#GvDrfH#@VQ6Nm`^a|AZvYfsm~_dN*00DVv7Y)T`@R0^eZ;rfk-H~x(P
zN6Qa<=$wq9)e3XA!61d+ULT}X?jpd4CFso~a^61CGTPAP5g`9?EYs1+#FBy)foyMN
zXCuiI7~2~q(Cv1|PUh~6q5y^n6zH2h0@_<jgd|A?B|V4_&+n4j!|V4~hm?eDLj<=;
zn5GhXKlj1&JU9#RiuK>W?X7C9$)?;UA-|qh3I-})YQOu*@mxe2?evWkSp4xU?`q~?
zp3=WK^*}fw&}xTt75k+arIgiOU`62cnGTVNN-=|E2(a&nKo|uO$K?dL8uTwm1dzh3
zm8!(p)S?vuK3`QqfbAL`ML=f}kd+v4M?iv>ekBH79f7Wq18hfU5zs_H%Sw#12rMUy
zVs>Zk9zA{}X@9;rzs>sDFKbt5;y;8r(!H@M1J8y4Ia;FWCCTki7jA7Ic0u&KMY;u&
z*NmC$nu<E8zahZRS4bZ3oWHp|y*caH#+XZA-z_ywVC?)HIht(0CM2_sa4VO0-yg*p
zhA=U^`sghRFV79>id9kxzG_R)l-5z}Zd||lWI@zQ!nhMd5as)RIZUD7>sQ`{9(}kJ
zt*>1LK^W49M|7kg%igLY!5LGuzJ3{+lIEZnuPm@boUw1OO~AmoZr_h3>+2FI^AFAX
gH&?-Njz0nn0QL`xjC*KnE&u=k07*qoM6N<$g8gkY)Bpeg

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/class@2x_dark.png b/platform/icons/src/hierarchy/class@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a982c924eca80bd77687d7c094665dd15d556c1b
GIT binary patch
literal 704
zcmV;x0zdtUP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!Vo5|nRCwCNmpgA0K@fmv_a62kLz0Gq
z0{8{cAW>3LQHKW61*Eh{lq3q2h!$CpiU18Y6%{2CiNr79Q6ucci8=drcbGZbiqF2+
zMz`Xm(Vb>yZ@!zI-J2DN2><gEHUPJue+18y;0Hc>Qe<q}AgDwMtxe(hPmk{`>3kbn
zhV^_8I_D#3wStUoG)iD_Gz6uzRR-(;IA!$ZAq8)rYvtN(C)5%E(=5znF*~VPB3J>W
z??w(bku1Qey-|Q}w>uZ)(j*IzlYs(#vr|CtRth1G6G24}w~oKvBene8xxP21B4isP
zxGlmYQ7||>0VyRw8{V?M_xoti7(+Jgwg~z2jMgyH)1}s)-2M*ZGjBvz00!;!jRS1<
zUt~k|r}~B3e|h1Na01Y32ecJ?r9N6~tG&PqU}d#K5Mim$C>{fxI06VlAEKxnfLDV#
zb_9TwUZZuTkIh=N0^s@86##5E=qLjw&48-(0e1ijjPfdd(A5-}8a2Rnbd~`_07g~%
zILp9xyeT#=_U_Z;0sjehf35Aae&cfQ2Hp6FaBcU`+IyR2AZ-9B&=%d^klcO!b9H~#
z1<~_Y(yf!cW1so1si=cG3jhb-A$j`h$IABN%UQ=Z_IYrnztuFrY4Gn9XukcLlhiix
z+j)5PaM`c!x!~rL4=7}o4QY$jN(<g<OXrlvQR|*N{>!s<QL6}}P6U3K?fca@f#G0S
zxf4n{xD<`Ay$bvwpo2%a)Q_cKRZ-yVQ#8K*GR!NQX)j*6z-E5AeS2+y9OAltKbDNI
m3s4pxnvHLFI(BjW6JP)>9*-*QeqH_m0000<MNUMnLSTZDl|lyq

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/methodDefined@2x.png b/platform/icons/src/hierarchy/methodDefined@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b8957c59905ff76c8ade5136541cfdf31546fa1
GIT binary patch
literal 364
zcmV-y0h9iTP)<h;3K|Lk000e1NJLTq000sI000sQ1^@s6R?d!B0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz4oO5oRCwB~lueGpFbsw5q#&9RU5(hF
z5j!ryf+Mk*bFkn@EVu-_5#j<!OeGS>q)7{ep9%t&s-*4n*Vuk4GBbQ4unja>jH8#U
z*%}{dv)0cj2`ED@Q~SwVL2}Rop@PKzn{<#>2v~@)2TTVUw!rSHg6cI1q+POo66B{g
zo{w%iDT@wtesT~+-J_iWy(xiq`UbN8{X?&^xd6=K9#HP?(SooPKyF_>W0sMQ4WCQn
zZ?}BOt0N&$_oAe3&@o+s_H+hm1t9wOrs5z?(N(_k-G~+ZgtLds*xB1@qO%Xi_!8@}
zrH}tm8bB2c$>lpf(hgKli8ZBz{KT4y-f=d0%88WzKYAsO0t^5Ms&{Mk1ElHz0000<
KMNUMnLSTZuVVjNs

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/methodNotDefined@2x.png b/platform/icons/src/hierarchy/methodNotDefined@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..d9961bed195734f0aa729ec26614bed298a5fb7f
GIT binary patch
literal 161
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*D5XoIPC}Ln>}1{rUgjo>{e_@Ct*L#D*KE8kB@1EN<SEm@#9<
ziA#Up-?wKIW3-E7o1pll;k|vmW6XiGM=fXZwQXT!U}R(XxIm}8=4hG%&^QK9S3j3^
HP6<r_N60qf

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/shouldDefineMethod@2x.png b/platform/icons/src/hierarchy/shouldDefineMethod@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..36e222c2cbc5ae9f6014ccc3f27f2f76510f590c
GIT binary patch
literal 350
zcmV-k0iphhP)<h;3K|Lk000e1NJLTq000sI000sQ1^@s6R?d!B0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz07*naRCwBA{Qv(y11_+{+VC}y5`l96
z#T-4)j7u#G10KM^&h~|wi3x1bzkmNe<5P>*AOT*U&zv0WVD^unzdn&|5IY;|CvHv-
zFdG;IcwNMVPZAh>pJ8DLq`r{tqW}N@efbY(|EI(tpew*8{U>M;0k8cBx(H+l17!yN
z18Ii2h~fW7N?i02$wd^z8UsZ0e~M%6-~UHImz-r}1bOq{eSB&e@#QsA06~NH2DpHe
zw)2KPKgbTFm3Ag&?>~M148kkzP0GnOh>?l0n2C{z1%w$H8SBXoY+i1zKRjHVVD^`9
w-+z(qA}&sj8lXY%f%pSACua#hwEzJI0EWhc4}q(gWB>pF07*qoM6N<$f*W6vEC2ui

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/subtypes@2x.png b/platform/icons/src/hierarchy/subtypes@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..302057bb466bf8016a62644e9d11aafcf82c177e
GIT binary patch
literal 469
zcmV;`0V@89P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzcS%G+RCwBA{Qv(y!$1PYQ3s4VU`RP&
zS*aaSile#@F%oMg3n{K;=U`=EW@g5#=I`IXB!vJ;4&WEy0Xl*WubQ7fe$mbWtZXa{
zoSgU_@bBM0+Bx7qFnIqF2;%>=i~>;n5{hG*rh$Lp5coq-4GkUehvDBJW`b&{S`I`-
zMZwvzS}*@|ak1l7|LxmPhQ-&!;pM=xWy`1-0{?(f@b3>nH8hKYr8lHNKC1=dXFz-a
zi0?wB6oA+ch~<E|g%mTHNG!VRfVc^2(Oo3*2SBV0#LZAOGzkHa!HrM{)MJr{i8Vs$
zCTco>kmbmZ_zzXfh~ya3a)Hm}-T#@HP%E^*|Nb-Z9iLBBE%(VX5v%?!xvq>vg#afv
zI|Ca#D~i~!pT7xaDHsTycL=L~qNCtHBNGE7GYgs+@!5+M{a79F>(?Kk0n8X;!~#<E
zV|T!BEC&20!2u-b$LfGTzyAVTK7TO8hy|qRA8i$nI$+cR009O7u#&{?b3tKm00000
LNkvXXu0mjfx%J7|

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/subtypes@2x_dark.png b/platform/icons/src/hierarchy/subtypes@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..f09e1d570724cde23ec47196d30f2240146bf2c1
GIT binary patch
literal 472
zcmV;}0Vn>6P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzdPzh<RCwC#mcL8GKorN{<?_SSf)3JA
zh5jGi+`0<l=#<6LQKi+*(Iu0ki)%L#r2j`j5uBWhNiKJNDQRu(k-LK&BIMwa@b3HG
zeezy%IU<CBzZ|3iXaN2dz~e<vOMH4aCb~IY6WU<Q14?P7CeL%D3K#+G?6wiYuhb;p
zsXYMCcOeX`0XXOO00fqoD@rVEwxH;*s>fE}0Y0w)Q)(;%FyM?THMQ;oaU3u255As6
zs})r0r_%)9_l}qQKomtaR)Av*I8$n@wcw+3Qasru+9%p8+N7L1MC+mLLmO^Qayo`v
z_Z8Z3zR=I&#dt&OqTQ4lD-|db4@!V*$^61MD6hjh0aS~xLWojJR$$D&g8u!ppw9Xa
zE$0II-bCv!H_E!w_|f?h(W*eW9e^KrYrZteAUcb*%JuRvmd0zhKoAEAb$|KvKQEJb
zDL|SsOh7k$y2B)14v<L_WCj2R@lpVm<#_U88$R7(65pJP8-NC2CcpqJF~nT^VW-Og
O0000<MNUMnLSTYhH_+1n

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/supertypes@2x.png b/platform/icons/src/hierarchy/supertypes@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..945aa25d175ecec46b32b2874e61fad400953658
GIT binary patch
literal 517
zcmV+g0{Z=lP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzr%6OXRCwC#ma$I5Fc60AI&E697a?Hi
z%FY|W0+nFy!V@r|t~6z5;t3E^cchA?ya59n3rH+fte_%F;<L@Aq@bpW?SP^(<fK#7
z%ia0&f0k3Klp>2XS^yLP{}P~iHc+fYXJSGs0vxCiGPT*Dy{oP7A8ylljg!=<w&aqE
zTb_vpJ}0ABK|l!OuF~q0ED=D_5~0kA#c*-l1?SQTkXCOE5Cnh?*j$WrbO0kjTD?60
zPiTNKJOe~<^9a)FtpNZRVGQPC0D=gO0<Bi-D|hoCvEE*Rcb_Wwnf3DRg@=z$9sO=)
zr)v<PQ@=S6pJATY>-DtBrKI5aZA?Zlqi=s`?1umo-*~?AH2u7o|NSDG${N{mw6l|N
zr?J#-^u80lpO{GjC*#F6Z9GJ8pg%^x*U|6ei`!TxfadCx&Ar|257%fe0B*I6r<-YW
zgvCwy>yOd(>7H_{6>X0H5s<B;%X}0lR~%BS=>epaB)2o5P+n<}SY;eRCV+6hrWuPo
z0pvshFy`b407L>a=H#q^SfBzD0VEi6ihsogKmm}&J_Q&6Ntpw{p_zhD00000NkvXX
Hu0mjfPzU53

literal 0
HcmV?d00001

diff --git a/platform/icons/src/hierarchy/supertypes@2x_dark.png b/platform/icons/src/hierarchy/supertypes@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..1bf2383424db85bcd9ba3790b66d889926011d64
GIT binary patch
literal 511
zcmV<b0RaAqP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzp-DtRRCwC#mc35HFc8Pjb<#BAV_;{f
z5N`q#NG!1M1YMXAYn!k$v1DRoM`9~)QlSbVcAyod@!7_yQc%;xc0f@Xa?&Zv<?j6R
z|17seN(rkpQUlZg{}SNvx-V&iEX25wfD8%eqOe*2;y_z}f3{DuHBMe5f6arY=PtzJ
zDTC1)2jtwitD^cm%LS060fai4m|9%zf-zwPD5|#xh+|X@=u(U^<%mXrqI!D(meWAR
z)ENNI%p)kOw+2A92&K3bL*&3U3Pe$q=C*U|?G^Z#5{W;vKG}E*z=vMq(O^9^2+%wB
zhsiU^3p$;SHo1`(oQx+hdL4cH&GS}}G@CWt9S53zLB{`n5zS>yt()%bGTCV+HB7(v
z((f}fDd3d6xaN&tl(&@+)Aw!VgY4oqRtjMA@z&<v4&Qf9NhJVY%T=eFYIC^7P5J8|
zqlc>_>9v~Loatu_d*^r6DBw07@O?di5CSSY15(K=3=+$dBPa!s%-1wyUL}B-DS*bD
z3IPxVQe#fV3h)&wAQXT=V^00AxCW>J%Gj3x0|1Y(1OB-yyaxaP002ovPDHLkV1iqo
B;SB%)

literal 0
HcmV?d00001


From ddc7bffd3ce171c6d29ef902cc4896b3fa9eb917 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 13:13:26 +0100
Subject: [PATCH 117/354] new VCS icons for Darcula nad Retina

---
 platform/icons/src/vcs/allRevisions.png         | Bin 390 -> 460 bytes
 platform/icons/src/vcs/allRevisions@2x.png      | Bin 0 -> 981 bytes
 platform/icons/src/vcs/allRevisions@2x_dark.png | Bin 0 -> 874 bytes
 platform/icons/src/vcs/allRevisions_dark.png    | Bin 0 -> 448 bytes
 platform/icons/src/vcs/arrow_left.png           | Bin 387 -> 361 bytes
 platform/icons/src/vcs/arrow_left@2x.png        | Bin 0 -> 607 bytes
 platform/icons/src/vcs/arrow_right.png          | Bin 452 -> 348 bytes
 platform/icons/src/vcs/arrow_right@2x.png       | Bin 0 -> 567 bytes
 platform/icons/src/vcs/checkSpelling.png        | Bin 297 -> 484 bytes
 platform/icons/src/vcs/checkSpelling@2x.png     | Bin 0 -> 1290 bytes
 .../icons/src/vcs/checkSpelling@2x_dark.png     | Bin 0 -> 1303 bytes
 platform/icons/src/vcs/checkSpelling_dark.png   | Bin 0 -> 493 bytes
 platform/icons/src/vcs/equal.png                | Bin 107 -> 165 bytes
 platform/icons/src/vcs/equal@2x.png             | Bin 0 -> 283 bytes
 platform/icons/src/vcs/history.png              | Bin 505 -> 513 bytes
 platform/icons/src/vcs/history@2x.png           | Bin 0 -> 970 bytes
 platform/icons/src/vcs/history@2x_dark.png      | Bin 0 -> 964 bytes
 platform/icons/src/vcs/history_dark.png         | Bin 482 -> 506 bytes
 platform/icons/src/vcs/messageHistory.png       | Bin 768 -> 536 bytes
 platform/icons/src/vcs/messageHistory@2x.png    | Bin 0 -> 968 bytes
 .../icons/src/vcs/messageHistory@2x_dark.png    | Bin 0 -> 972 bytes
 platform/icons/src/vcs/messageHistory_dark.png  | Bin 0 -> 540 bytes
 platform/icons/src/vcs/not_equal.png            | Bin 212 -> 449 bytes
 platform/icons/src/vcs/not_equal@2x.png         | Bin 0 -> 921 bytes
 platform/icons/src/vcs/remove@2x.png            | Bin 0 -> 1132 bytes
 platform/icons/src/vcs/resetStrip.png           | Bin 481 -> 470 bytes
 platform/icons/src/vcs/resetStrip@2x.png        | Bin 0 -> 817 bytes
 platform/icons/src/vcs/resetStrip@2x_dark.png   | Bin 0 -> 818 bytes
 platform/icons/src/vcs/resetStrip_dark.png      | Bin 0 -> 455 bytes
 platform/icons/src/vcs/stripDown.png            | Bin 474 -> 444 bytes
 platform/icons/src/vcs/stripDown@2x.png         | Bin 0 -> 761 bytes
 platform/icons/src/vcs/stripDown@2x_dark.png    | Bin 0 -> 757 bytes
 platform/icons/src/vcs/stripDown_dark.png       | Bin 0 -> 442 bytes
 platform/icons/src/vcs/stripNull.png            | Bin 457 -> 493 bytes
 platform/icons/src/vcs/stripNull@2x.png         | Bin 0 -> 856 bytes
 platform/icons/src/vcs/stripNull@2x_dark.png    | Bin 0 -> 856 bytes
 platform/icons/src/vcs/stripNull_dark.png       | Bin 0 -> 494 bytes
 platform/icons/src/vcs/stripUp.png              | Bin 475 -> 440 bytes
 platform/icons/src/vcs/stripUp@2x.png           | Bin 0 -> 782 bytes
 platform/icons/src/vcs/stripUp@2x_dark.png      | Bin 0 -> 787 bytes
 platform/icons/src/vcs/stripUp_dark.png         | Bin 0 -> 439 bytes
 41 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/vcs/allRevisions@2x.png
 create mode 100644 platform/icons/src/vcs/allRevisions@2x_dark.png
 create mode 100644 platform/icons/src/vcs/allRevisions_dark.png
 create mode 100644 platform/icons/src/vcs/arrow_left@2x.png
 create mode 100644 platform/icons/src/vcs/arrow_right@2x.png
 create mode 100644 platform/icons/src/vcs/checkSpelling@2x.png
 create mode 100644 platform/icons/src/vcs/checkSpelling@2x_dark.png
 create mode 100644 platform/icons/src/vcs/checkSpelling_dark.png
 create mode 100644 platform/icons/src/vcs/equal@2x.png
 create mode 100644 platform/icons/src/vcs/history@2x.png
 create mode 100644 platform/icons/src/vcs/history@2x_dark.png
 create mode 100644 platform/icons/src/vcs/messageHistory@2x.png
 create mode 100644 platform/icons/src/vcs/messageHistory@2x_dark.png
 create mode 100644 platform/icons/src/vcs/messageHistory_dark.png
 create mode 100644 platform/icons/src/vcs/not_equal@2x.png
 create mode 100644 platform/icons/src/vcs/remove@2x.png
 create mode 100644 platform/icons/src/vcs/resetStrip@2x.png
 create mode 100644 platform/icons/src/vcs/resetStrip@2x_dark.png
 create mode 100644 platform/icons/src/vcs/resetStrip_dark.png
 create mode 100644 platform/icons/src/vcs/stripDown@2x.png
 create mode 100644 platform/icons/src/vcs/stripDown@2x_dark.png
 create mode 100644 platform/icons/src/vcs/stripDown_dark.png
 create mode 100644 platform/icons/src/vcs/stripNull@2x.png
 create mode 100644 platform/icons/src/vcs/stripNull@2x_dark.png
 create mode 100644 platform/icons/src/vcs/stripNull_dark.png
 create mode 100644 platform/icons/src/vcs/stripUp@2x.png
 create mode 100644 platform/icons/src/vcs/stripUp@2x_dark.png
 create mode 100644 platform/icons/src/vcs/stripUp_dark.png

diff --git a/platform/icons/src/vcs/allRevisions.png b/platform/icons/src/vcs/allRevisions.png
index 281dfbb7ec292fc34cfd5f9255f7a5336149819d..b3572a45b3179c245bc77215cb74ccd80a63fa30 100644
GIT binary patch
delta 445
zcmV;u0Yd(U1Iz=E8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00C}EL_t(|+KiIFPQx$|#y=-^lDaTeVqym&SWq{lJ_1On5(5j}d4tY<
z12%?sNALnHFtD+KsE}Z8g*s7%{BvV`6>USCrv0ST*>QZi`+t66T5B|$&1Wp?-NgCd
zI`15<R;y|uUv&BYZtn>cMdI0wdAUkC?T3;{?lbVt{2A%=?P%K3LI<iJ?%HM7=S*ZD
zUoGq4UxBC>T-eg>3Ms+M5^TuyXprcet%o+{<SWvJBUp|NE?roj`8orHEn%nLth+Fx
z0hf0mDo#hK_<tZ7MMzYPSo=(|fE{-a8<bH>S>XsI=HWH`9+s2P$2!WzC^np*`bVuX
z+23wIwu#Kz1s04lM2L(bv|nf<iJZ193&we1fHrrXF%hj(q#7@AFK84N5St}%&z-es
ziZNjuD29-Bp%S%X1mkqpc_J|;q9PC>Q4yVWJ-D2X6*l;Y3>hL+=t1@$&#L}eJ2C0n
n#Lh|+=L$}iXL*-NzXA*Z@CuQxk+dtM00000NkvXXu0mjf&9%jI

delta 374
zcmV-+0g3+11BL^T8Gi!+001a04^sdD0H{z*R7EdCVE_OBFGFB#ew2HPpL>m=eT|}^
zth=bR!iSixuDQmsyvaXNY%ahmHN!Vf$yZOsS7OC;h}W2l$F)AkMpMyGThv`%)nPct
zKVr#pV%2D3*l1(eUTWELcGrA%-FSG)lYrWWhvJJr$3;5ELw}6hnwHqDm)NhI(7~M8
zx2D#}r_j}>(bcir(6-~tzSrKr-r>XK=g{Wt)#&Wu>h0v~?d$RK@bK_3ITFGE000bh
zQchC<0L<&__4fDr{QUjeQt#LR004nWL_t(|UR}!74gx_CMA2qZ>6ul*-QD^BKcj~3
zkSzD5l9Qs+UvGeli|9K7@5jv}s=E<*p7#KLVFd1nO&P$KSmC;3X{~UaESv7J>MCqQ
zzXmvkzCsiXnW!BFiNdJIfW~y*QJAsRUnpd`d$h*ZDx_urz?dJHY5_b1zz7uk0P-FQ
U>h2a$5dZ)H07*qoM6N<$f+;Y?*Z=?k

diff --git a/platform/icons/src/vcs/allRevisions@2x.png b/platform/icons/src/vcs/allRevisions@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e567f3ec7d387714dcede680f0f48e83cd9e383
GIT binary patch
literal 981
zcmV;`11kK9P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#cS%G+RCwCNS4nFWK@@&f)!Xz;L_7!*
zPv#KOh=_4HcyJd5QN-jFVS*xv0e?WigOGoqHzgx3h#o`)mngU(A#ouH5ffbSpt*=>
z%uG*j)#a;pI(C+s$#gR24Uei<)z$s#y;t8iMT8Krm_i~4y1TnyCs^NFYHMEG)6)~K
zRT4Trx=<0Q)d3gv@j|9RsS?^5VpHej^YqZMy%Sq6)w*`JRMixLn@b<9)j>P!F~1Sb
zOA8SJI@bqpEbYqzr7r`MHL7L`{#y-PZ+Ku5LM~9IWYv@bMnf8AIlAZT;=r}cgVp%)
zTU1k9^t1_D#stOCz_VSrwft$XV-<U6SvF;?Bfp;{a^On(UY1gJo*7zN#}8}i6fjKz
zLH{O>>ME!rsJOcz!1;W_2oQyVlG2I%xC}i}8OXp3d?{fR^d)IfGnH$>w;g~V35&2}
zd|yt@7+Y9MeGd$GBRKHD4>cg@ghqiGN=2m_n_mqa`M7oXPRpBC2;c$`$j0XmzTMD?
zO|E3d=W+{r3Jwi#w6N*C)AH&W;Az0VDfo=sch${-e~xU*-Ci^BN*C(GqVG1AfGM17
z|FtLLhURE&Ho@nT1CbPOY~tO{59`h~6pR<sraqPQUfqx|62sS4?j37=g56cI;m>^y
z13Qo>zSfluO9*%%qT@Is{?-cH9<qTZ?DpgMa9tu01K?(<A~q)Z0eNBt^2MOQ6BEtF
zb>0yOku8S%CHt=fh?EH10F0V0LUiEyyD$=`pb8dNb>M2|zKDka?RZE++(%x33|kiR
zgia|CRHtBdaMx=UfoKy@J|$HhV2JsYR?d{<1<4UoB?4;H#0~)`Z>{!icMx&o3_f--
zkpmL*6+^G=fZR3mLzEK98zE0ng3%y>TXc$;l4KE(crJHUwLb6%v6_(O%}i}rg`kZG
ze1!W69XLF?d6LiXt{;*dkd4{75-()2-#hKd<br^oMzuu1Ll&L)DZrdg!F{wRai4o$
zn1-<Gh3Miwzw8%X@bX3Qunjn$zXR6ypJi?CxsVd6Zw~QxbJrj7EgRf|4czv^-Iu$7
z)y4(*!s&K2Ciy|~glE|!&UhZ|@dEgk6Yd<3B9!w$nd|>|DaZNIX=$F!>#7nztZe_X
zy&qexUN@sDa)P%<-KH2s*Y#>vPMVW0B#V7L|0BQv20(Mjz2G(Y00000NkvXXu0mjf
D&0EDP

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/allRevisions@2x_dark.png b/platform/icons/src/vcs/allRevisions@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..486c7b45bde5f2d6eee51649f31b724573fbeecf
GIT binary patch
literal 874
zcmV-w1C{)VP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#3`s;mRCwCNS4~J1Q5^rjkNF-gyoDB_
zhlDyxT{;wXkiPWdAyQf`WYZ22WVa5T?2`@(OQ^e6(4j*`1s#M6LNGdRq=zC(4}n2~
z`!TaS^LlSuW7TPO#~J+(f8NZzdGmhrd++^zZxCY)wldHXfJ7qkF+ls4QdxD|cs%a4
zr2&D@gvCI$0BoKUVGaRZgW6S*fn4uXXQHc<oE)vTt=~{p#lYR-_+AaG*DP$;^UKjN
z7{Kd&@J=xmLl}K<HB_${I&9h;xMh#&2%%vj(U`1jpw=4Tt(@$#$A%&SaMK!V=3o5;
z%hEpC)IqH=KvESb<Sn>IA1AF$HtExB*}bdEITQ%MV16Wq2_B-FY$!E42mnNufbl_N
z1c0a%B&JsUI_5aR8Nif)q^rp5Tvq{06oh0k*9AlfDBDa9%B}eFLe2tM2sjA`Xm?7k
z)ecZY`3w|+%MXV+UNX!8D-?(>S4^zZjm?4n`Sx^T=c^WQ*)Sj!E3fPQ*4oXBROzz3
zE*0u3i2pb)=6iQy*UNVt#4tbCnX`)ei$MXbTL<FbPo!L@xL<L|T+z1tykRC19Vm~!
z*|tv^lE41UeA~66>dT5Ud<K@naMXq~3$1VXX=B;#uaBG;hq+J8M(u_oj``6&kAEM0
z;6884xz^-mdNv&y1Ettg%6}pJ!PW2%uAEcCH=<;~SNCNuSRh1~V%^T<lD7-VBiu7C
zT#<VgHw55@HCk!Ym|Xh$8dB%^1YqnX2hmxy>=y1P9Ro^FI`9xsMG}%+F@-M(fABm)
zlR(*SaH%$c`$#kIVQSDCIUkq-q4|=gRNmPV?D>Q1{uL<U8^XN!eBg;)JDbl11|alY
z==xg0_#u3v{LREv(h`D>OZMsMzySJwo?7YWe!3sKzx(y_y#ZrfIo<yL`L=A>tH4+H
zonpZo3LcBR^NU=%$D>+?z9Ia<l+C#uSVy^JPe-W(zENkH@7sSJddQ`EIt(eU_E)R1
z<PQxzCxtF;HUmv%5*@i2{m&aV_IJEh@kf9G0J6CE*R+*ftpET307*qoM6N<$f}8r9
A=l}o!

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/allRevisions_dark.png b/platform/icons/src/vcs/allRevisions_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..c10997adc3551c0b53e15d2785e7709246934665
GIT binary patch
literal 448
zcmV;x0YCnUP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzVo5|nRCwBqlFv@UKoG{i{l`)&(YMfp
z-gpHQpTL-Sk&EGA^jRbxNIbyF=ri~V-ZU{DJ!{Zl%9eKNx<ddfl){&6cBZ>KnfZQY
z&N*~CohK~o&9BpGTy&0BtJUBr7CnBvuHS=JnPfikmm9P*V{1@60(funjCA#LGVf@q
z183}>2y|4@)%@q1RUP~*Fplk+41-s_Q-|6Pp_FzkW3C-ObZK{K=1NCkT0(AV@LFY(
zD-lADgZX(Hk6?#pbqAcGH-<e(69bzi7=HAb>3_5H_oF85{xK`<fMf^piw%;HWr(nW
ziZPmOc=>tUoTcsHt~(*Kae)O95hCLW?XMkyoaREnI}h)CSLzB>y#`4D1b-eyrde8G
zg0HIo$OsOmB*;CHS#X<r93>-=(|PBK1QAI*86w0ysZBk&m<93I0HY`hiBPEr`F}jG
qDUn;hcGsG?P;eF=7Ck2Y3NQdc%$8c5IwSZ10000<MNUMnLSTXbV87)6

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/arrow_left.png b/platform/icons/src/vcs/arrow_left.png
index dc31e25bd9db78df6dd1b716cd027f0bda8906f1..220ec70d51f30ca64deb3fe518905213a93a7317 100644
GIT binary patch
literal 361
zcmV-v0ha!WP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz3rR#lRCwBA{Qv(y10{fofkJ@S0R5?s
z^<*1hIMcPBm6M}^kO3@MZJyy$&&9{rz{E`0hm7cfs58w8sF|mMlaH6-|G)nX-#&g~
z`1Sn<ikg4_{xMw1+Q*3D0?jE7^_;vs4XoVUKpCJE&;WLzL9E<dC<grg@e|VvYLo0B
znt6bVS(zFB{{IJb9}uyzFfgO}^v}P)m<BMjvof-9u>(bz82%zDzy|*Q{fik3*VFel
z{Qmp95r`QG;(x!fN8_caEe*fEe{cK)RP^`XADs9fk_#EJC1tHet_?sh)q?`@a^!YK
zk`vOkxZMrEfiC&|<2&KB3~~W3tT@H20iQewGY)ue1PCwy`a8Iq5SLba00000NkvXX
Hu0mjf5Qn2?

literal 387
zcmeAS@N?(olHy`uVBq!ia0vp^JRr=$3?vg*uel1OUIqAsxc>kDKXM^Ma$}N5n`uz1
z`_$7637t^^UDjQP8Tt-0WUpW_sbw&(X3#5V&@5t5D`YTFF!k$K>p#X&vYDY`3q#u;
zhT3fmB^wzsS28$N8<uQg&`ebJZWWt$mZ53~L(V#exMd7M^BCNwGuZYq7_>7e)-pIx
zW>Ak&cB_}ES;tVejUi<<gWoI$m&ptky$rf73<|XjI;{*kaT*rI%IOOjl2$Q<EMV}O
z!Qe2N!K8;lvxPyXhC#T3!79bVGEYBr3PaEW2Bi!J(P#$YXa@cW2JTP>wqOR&L{EoI
zEB9^&w*n`x91o8Y*V_Kt1t(N)0e#I_666=m;PC858j$1e>Eal|5uKdCz^KN?a`afo
zgAISgn+qC}-t-h4P~b@2GbJTuiercIrVk9A*|!W*k9h>~@RXg9VdHl@mRnF=W}vt`
dLHi0T!)9H!$?@xF*8z=W@O1TaS?83{1OQF{d4K=_

diff --git a/platform/icons/src/vcs/arrow_left@2x.png b/platform/icons/src/vcs/arrow_left@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..8e166ab7cc8df35432d317ccb0884e313ec394b6
GIT binary patch
literal 607
zcmV-l0-*hgP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!0ZBwbRCwC#SIth_KoFj_y|xqV^cg^*
zRST840ZoB>4;*OK7Wx={0I#nt<@d%5pdJuvt0E!9m17~Ga_Ac%PCcXr;$1VlkP1qq
zY`m7aWTa1tBCY0|Z@!t`kTgx<K7;fK+&2M`1hQgyc_K17FJWaRKD;^=5zAtx0yvqH
zuS`bN^O#K?D4f91b@Ear1lzWYCGccfCU;pW3_%j$&BU01wg(<BJ&zohGCvH!5BtET
z6wpS+jNzljnv%U-2~_3y9S9+C*7yUzPfpdRZv1+`N4jdk!-ZPppzI!2E@8PYh^zTU
z{RlX|2d-vv!FhKc82t21CHI3qkg%le*Ym67vmGcssDKx6EdtH6bA1BU`LV0YgECf*
z$z4bF{8r1*LAFQ12CAn(D)a~pd~79e$xfBsOxLz(bN&v2{tu&=oT|#*u-v|KgSFq0
z0B$#;k|QkKbT@l$8bS!YF&tT+X6Wunj#{2^(fAAXci%|IMRYLxm7!r`X_{OCLVpwf
znAu=L@HoYTd7`UTy#I2OaU_wK0`1z}@h+&p`oaWH;#6?R1DT&>Pd~q4Xv*mS-w$7Z
zH*%`>ZFux%3)_)kJ2<q!lV)+(v5cQ@w;9S9gESL@UldG0k(k~2Hy!AW;t9w&p4&wd
tBF<$)nmnniYvauHS>F3+)FW^yzyR?=a~mR_;|Kr%002ovPDHLkV1f$O6*2$-

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/arrow_right.png b/platform/icons/src/vcs/arrow_right.png
index 96305091ab07469de5a2cefa6ecb92c01a542383..cf182909fb517c3013946c17a84995616c28cae4 100644
GIT binary patch
literal 348
zcmV-i0i*tjP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy{z*hZRCwBA{Qv(y10{fofkHsg0FS=y
z^%NPv%Ff#0HE~xx*#>ZMvN3RSu{C(~@4#vZBP<YId$<2*VnQ{Kjh&T&hnJIqk&%(%
z>zD5g-@g86*j?<|h}8w0+#C$N0^BGVB*w_h1jg)~>_E)c;MBFX9;*S&tjr+)qF|61
z$bJ8Su4H0?7{bBD-r&%=8Eyy*jPdu+KZZX*j1MpZy~xT2H2CLlMoa_#{sUut02E$8
zHH~|VJsU6$_=n#Bkmf(X|1@sPa%#XD3%G#y^!@)qu>jJ%BiE$?U7m$dI{5YT7bqGV
ucjdb^;B*>3Y}dA_0iQhMfagYl00RIrn2F`(N~oj&0000<MNUMnLSTZckDK8D

literal 452
zcmV;#0XzPQP)<h;3K|Lk000e1NJLTq000aC000aK0{{R3VXLgw0002(P)t-s|Ns95
zQ@I6V$`DtoByq<VT&@5^rYd*I2~)NdV!ttf*%Ds2D|E;oX0<ng(hF9z3|6uYR<jXX
zwkvPBM2p!!e7;A6#s*WX3stNSSgaFUtP^<H6<e$veApm;*CBn`B51ZIamFcf#wmo{
zEQQ-GgxW55$uNiAGkeQ4eatkB;5d!mJ&xc&ljB2^;Y5?;MwjGAi^)ou<xZOAQl95h
zpzKtj=~a}@S)t}xq3T|y>td?$WUKFIpw(%q>1(LxY_9KgvFmiR@^rN8cDD9-wD5Yk
z_I$43eYWm~yzq*{{Eox+kH-6z%m0?m|ECSe2LJ#77j#liQvl1$<mK(|@9^;O@$&QZ
z_4fGq`1<_)h%tZA0001QNkl<Z2wP)d00SllB*4Xj#NqK}2T>e~N@^OK_TFB6K#q{J
zg`J~^r>m2X2m^zlp1it_fr*uao1YkifQp=|w!X2Yjf=Y|1HZJavX-uqnYFDj0|T45
ugrt;=f~h$#+-Pn?R)jsA%t)3pf=K|-x(o`R20x_$0000<MNUMnLSTYLGu=x7

diff --git a/platform/icons/src/vcs/arrow_right@2x.png b/platform/icons/src/vcs/arrow_right@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..e87edd01e3d5e4362a3c1b048905426b514f9135
GIT binary patch
literal 567
zcmV-70?7S|P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz*-1n}RCwC#mrG8=Fc5~F#A%XNED*N=
z@n|XR3WzHp#6v9DB9Jl`QY8upfDK0g)E5#PK;=k%Aez|NfmRi1X;QoGrj|zWBIEh|
z&v=|@j4?FLq0IoM4S)oIjAaXDSH@qLmQdGV<EG+{>Mspo*$HHtCS<QigOCPr91A5=
z7KgyF&eJh*0Bjl@!0tk13MF@<08G=6VPfQ@9Bwwk*o5>|bcoO~T+J6FpG%v|Kff>+
zJjFWgFAp{9E!1p$iaETU<w$G=Z~_N~6~#>cF5(JMaiqAf!P6mBaFUjo!%DvB##UhK
z_LU_pGg|(1J*WZk?CmQ;iDrW<QRhmuJ*b^;lgI$O_cbOYm2GYvh}Lg9J}!1hq!h?@
z#?FR>GEUMCjL%`|^3jb1Kq*sVg2TWDvbdVIBTk0_i{v2$fkO)XE}&|3Ab!AF+E4(h
z7@!MbC&<g`CJa}gCyxqmTv9q*gT9?~+yEl@)7~-+Y~`U8Fm)*q!HfGV@b6s`F2bKe
zR3iJqDvbS;EO+<L`UNi!$oWtO;tt>U|F&XMIZ8uRf9dPkYkS?orIf}Bt^|O3ET|jm
zGg3XyKwN)aL9O%MQ}TQgKe&?1Ctaw5jQ{M<Xa?{tzyN{y6R?FTqAvgd002ovPDHLk
FV1n&k_2~cr

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/checkSpelling.png b/platform/icons/src/vcs/checkSpelling.png
index ebef021e881af0023e69f944707f48fccaf16b82..b4977fb506fd7eeba44b79fbd90b9804da1a3be5 100644
GIT binary patch
delta 469
zcmV;`0V@8f0^|db8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00D+cL_t(|+G70w|33pIfDvRsR8&+wklg^qjX(@D6~>3jgY_(1whY4n
zkOoGmMtn3FAREAh<QjCp{714CCqOoU5#4*F8o+?X1&vTPEPq_Ut~8wC++Z}*70hNq
zvz-x#YhVG)aLw*jFc%+R9U~(nA`p>*?lh<W|Ns4)`uESD-0KBLP$YGxIOuWm@gC<E
z;OF}H=P$#dpyiAhUSQ|tVPNOy&1Pa_>q8b-pJ*$}%*nBlm79x;frXjj_rJf>v4#N?
z8!H1)5d$k1XMcglWcyB#m`blD8#5d0YM__`BT)0tA3ryJ|ME2#s}~HG`Zlm}an=9(
z{hQ&(=dTPuzkF+AWMUNK;N!_)=ivqh<NwP)zkId2l(78^Rs%plf4Of1Gb>9yFdP_u
zfB(q<3NKbp4j|3=<kz?FmRA#YJwZu{*nsvD53nIf@=o7?hFRW7+;a&dFW>?i3!NI6
z*;(s>&i?!7`>&vzNe4Dz%}n@!+B~}kpqf{=lMheBnHwnq009O7r{$z&@sK+$00000
LNkvXXu0mjfog>!2

literal 297
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbL!Uw}`DD?=`;b9ffRB?jm4OoodL
z|NsAY4$EZ7V>@%^j1!QN%L-%z6#!*{;t&y#`il%eEkG_v*CHl{#mo$gnScr;zwIyr
zSyK|^2eJVQe0^hpV6M`o8$f|7PZ!6Kin!QQFNK;Fcv>%>UbIc~R*UcNfBLt07XE$s
z+~SOF!&9+ov3%-pIXovdT5t-@x_mj|%r@;EoIzjDrmxML`$6PPKC|zNPi~jyZ)$Se
zu%e{dr+9u&f#{~{dptXyU%%17_(N-(y3HQ1^!0xad_HM-%$^~kM<lP7u|AFc-#+vE
QoFHd;y85}Sb4q9e02uvhZU6uP

diff --git a/platform/icons/src/vcs/checkSpelling@2x.png b/platform/icons/src/vcs/checkSpelling@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..e822925c1ca780c399d487420f37cd8cba3ab137
GIT binary patch
literal 1290
zcmV+l1@-!gP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$tVu*cRCwCtms@CDMHt6t&N*{#yPGPC
zk+Lt=T8o;8;H5<|f>@&wqm59>dU;Z$4^`1te5&Arh^U3;q0eGTu@{vPBY3H{mRg%i
zQ;VP|sBr~RP?BtR_uOXu&p4+!NjGM<`_Km``7yV1X8!Yi-^`q)LI`p(lR++WveH7S
zR7#8YfDd)~J}{AaJ~bBye}Ip`cJQZe?*?W4UKjWgyaQex9UX1i0{4Od)Ifie{wg@E
z#XK$t*X^soG4P}o_zk!QY;4H_O9V`TSg+)nCH+5vO<*<n4Xo4cJHT3Py$3)93gEJK
zV&H16`U`L*Q_m(7Tnc)1{Rf>tsPmWf<TA~HpW6{Ip!3hcrx}Z6({<o4Fb=*0J9Yb7
zouBDs7xZiYNz?wGaYHuEfCFF>tOw8PcA5#$_ICl22kz9OPG{P0mwjh9R_Z+`in2b9
z@)ne(E2hB{sBcHTg7O-0E$ZK1hz0tzh%<VH2egn>STpf9aCQ9?oxcb%=f*|(ils01
z?C#szOhD@Y7r++Hb7>!6I5DrnpdTau9$YTZ0^Rot_!~Sb0~602(N@`&d6(QUa>pPs
zjFDynr2j*`m(z3tG-O}qz|Moa^r7=UcuMw7ZTR&UWVh+IOTY%b3y!AmUcbAq$6{=+
z?Yd?<7)|ej%t_cZoxWwdqa&A6S~M-|OTVjtoRQ<hhv;$#QPb4Pokc0}scDWmzF%|;
zc_O$te-|uwR<C>G*4Nc3$BDSWm7A0r`<UbOI+)yY91_+Wt>1>!G@d60-7AQ&LHmD{
zzG->RpworPJ%<Q`E?Ucq0+{C#%eE09bR4EDNb|J{-q~u|>}e;TQ{%uIgmW(0)3N|3
z=Mz_|ckNBE#Ag_~TL$h*;9R`lw5<^*?-Seiq$SnL6P`>YNxbd9Zo|bcuq;@B5xF4z
z-x$?{<D4h``mSHj?>&ZTz0G{zWLN;POd`($!TH%Fib^LRem7~^0@9C$We_{>DN8WV
zS%cLaL;KB5S5HI{{Sz$bu9EK<%u-`ObR~|Wfv<-4&$RVP29xbf1XoX5zC-M;oD8OJ
zY8Z!w;CFNMrJ(LpgT9CUqMgI!wgt0uIYuptqM?&R`zvjK6Hb-J%2I@iT=-E&vI7xV
zVV+v%IA(oJ`CJGSF|yBeottd<-EbLp0FlCyIF5%;J#=ug)i0v+($||0mU|CvmcD&i
zN;X{^w~#V93+L-^@hH9$ldnds4B9yt{Y+iXFuU~o4#dq^JD+4tQ`88`ro%EK7)1DT
zm6X&Pufg<$6+B|XO|oCPgo{0K5bO$O=Sjx`g4sC)qQ4+Qew)F^PTo~PD)%_^Y+Q8G
z8*1_ok|5d^%*~UqTI*auW45YRWeaaX1k6lrlQ7HCUyD=)9UjDXiysNA^+XCt!l-ir
zNf44yZM7yMOuDdXxv20s8NlQ-YVsgb?{q9c9-#sv)L=@4Up5@;oI7-?Ve+A<7F0q^
z9yfwTH(y5rh(2gym{ZLCTegW;mU~@`NJPSi5%H7ZY>gn7JAkZohqfU=n=z5@;Bbew
zM8Q=eFi|zGhhq^Yk87Ab;Vpec(Et6f<9`Gg0Hpd~(H_cMMF0Q*07*qoM6N<$f?iT)
ArvLx|

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/checkSpelling@2x_dark.png b/platform/icons/src/vcs/checkSpelling@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..566ce20ea467713075654e15f8974d78343f116f
GIT binary patch
literal 1303
zcmV+y1?c*TP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$xk*GpRCwCtms@CDMHt6t&i$O-O)HAg
zk{4?&qKyz#lnPPA8jTojBuG;AO{5R0f>wM=p$j771(Sz7i-ls-s>C#cm)2gW+9<XL
zK~V8Rs-h?)+3fDQ&G`RLXPeXQra9|A^ubAf%$%8X&i9}1`)1}Wmr}AzSu}Qui&1M#
zOia|8_kj;o`vEYWy1(Ww0saIZg6F_rs=pl+)pKp&2k<s{X<%R=vj^@6J}85p2ID1g
zNQrrZUatDrfaBmvCGZ<?9k@M{2kHcz0+E`@({<xNfh}MiI0H7S{+(ch^4>!r1O;$;
zGdXarQhf{@NnNLl4lV;->iT<CKdkCq$~cup@N+W)dR6@?_$1|#bh!ci1E#=tU_|wA
zQ1$6nRzZ)7AG!9AR2b4_o^lq<fa}3Cs-LG4G;`s#eE_S#MfEpu>+Y#g9C!adRvEc^
zm~Ng$`zEw06u*KTuGixFN3_?2O}PHH-q7rhqpNzLTNyvCW=MRk`tDvKfi2*u>yK6a
z0>qqqFWOhuKiE0iy}i*YsKx(zwZ5s`1rF1gkn*7Fy9O`)NG0bL;C*q{i!TCN?2m!X
zxMxl!@ezz~s~Ooec4r^gv@tZt>pej657b(&mCr$y#!?%09^9igo%g^~G`8!v(O*#A
zq59T>+teyJT6^}!(e6&eH1}AJqc_Tdizds+nKxS6ayjQ6x?z0gwG~jC?8M*!zS2h2
zu(Wb!an3xh>yx(UbvT7QlR{p&6RxyZZ+vz0D{7aM|8eFz=h|M=w!3T?H*A{)m1_3W
zkn7sBOyheblNM<HkMq|I*Y301VBEEt)HpT@nO%VCI?S-FAxN2m>k8z)tl*jLhGp)s
z^SR_b@CFk?5aXEz*g20mq~5W%z!Qh@>UK)p)xf^^pl%sscHU!_=aMIrna3iYj^k+f
zVyEHxAutShz+^Nb{NEf_{1ZaNJ?gAqDej$`ZoFlBo^E0S%+ML_6;g=VI1GnQKKf3a
z*#i_u&Cr;YcN0&TuDu?!Igb8Y8_u4|4vbHmIcE($qnSqX4v3zM!m#&?{(bXJeUiat
zBe4|8orY&Kt1U;#)Q;Wkkd)$Hfw3C6_PEC1#dwF6gK^7%+XcO&9EM^4$^LzFO@9-f
z8k#JUh$M3nN6KUyA~3@|H}ol3eLRV|lsa-`ukP5lSctpkm{<XfgvC)54SxB^{+X;_
zL>H8=w(c)>9oR~--A$5p$HFO;xZDhuDsPG~x(deEAy@jWoP%*QIh^5kiu+FF&15s5
zWDQGL^^3Y~rbL(!;n6HPD_38J>zP?_nT{~gcoGsJ$0Of=-CtN@Eer4$7LkbFvIzP%
zLyYablO!pvanrS!rcpE!;|F6u9QGHNSWqgrE}*(lN@itAcUc77%q^XnhONF9d6IOv
z5z8&w7L+P635bKRbpf#-upn7#4MgaCdC>|vC!)9)#^)2`ewaMdvH;pbB}61IOGJ1@
z%{I=3LzOa&_lISFE`af<>YsP=wIqP4jV6LS<>J}4#oQvTbtNK}u^2?g&jbr)hMHEu
zs%K~u0+btL3Wq>AlqU*KA_9g=Q6-oRVLU3scq}q~MDYLpuj79O7y#Y5Wk!TwP@Dh&
N002ovPDHLkV1n)We82zz

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/checkSpelling_dark.png b/platform/icons/src/vcs/checkSpelling_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..82b9dc6be493ecd7b448be4cea27cab9e76ae204
GIT binary patch
literal 493
zcmV<J0TTX+P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzk4Z#9RCwBA{Qv(y10{e3M66!Dx*kY1
zKyf1w!%T(oVe%lr7#bRiY5-J{5vs8frVxn_lg9u|NNjY!{714CCqOm;-3CTd4Pe0H
z0+@GT;R1H0;SA>nqnWP%k;8xy2hD&KMqt;pzMUD&#m862$Ouuwh#rl))13bQ|Mzd|
z-#>qHuNNFak<^*upvTF_dz@Q<pX=YBzYK?hmNQ~_ft{C!ft{Z>n~9CB4_RD&qOB-1
zC&xxsZZ0kc7G{Ru|Nc(L8U{>ktPDU!46Iz71sap>J3(S9y_RguY^<w+VhW5v%|Czq
z-1Pm+*IeW<fP-Iuel@bOvDCA0u`{sz{Zpno(e?+>P%#!R4tqv67KUHHe_j6h<!kh%
zgzbN^h5-oZFZXR=W@V`dh6BUz?>`wp;l;|y0i+q9{QCCY@@m4aC-At&l^3*^cz_K-
zlK%!Y%<@L!o=Yf+1z%>;Sm@Ni%+6ZR@c;kcKi_`^-Ap>L30(~%q1>o8&#nQe=GE=w
j!_%<IGg6wJ0RjvF+t!t09r-1`00000NkvXXu0mjfRNUg+

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/equal.png b/platform/icons/src/vcs/equal.png
index 93db4279059b3cc641dc447eabe20e2a7fbb65a2..c9b5aae892ef1956239f760e054abca6cb7e7ff1 100644
GIT binary patch
literal 165
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*D5X+&x_!Ln>}1{rUgjo>{e_v(d?bhbMti@Yv?N|BQ`|ColQ<
z{{DWR^x$&CCf*-M51l!1>Y(2w#{KnwST6T4%k?f!G|=H;;4oll=arY&o^V$ZXe5KD
LtDnm{r-UW|Ah|b_

literal 107
zcmeAS@N?(olHy`uVBq!ia0vp^JRr=-3?y@QpIZW?*aCb)T>t<74`hZOx?BgO7)yfu
zf*Bm1-ADs+ggspxLpWrU6B?L~{g<D)VPj(wgO3UG^Sxj46M@nUp00i_>zopr0A|e|
AJOBUy

diff --git a/platform/icons/src/vcs/equal@2x.png b/platform/icons/src/vcs/equal@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..6af5aed83f25bf637a76e8fe77269b4b0361f2e5
GIT binary patch
literal 283
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz$r9IylHmNblJdl&R0hYC{G?O`
z&)mfH)S%SFl*+=BsWw1Gdp%toLn>}1{rUgj{;&g+S{ozVVm^t|11p%_WDhVUzwq0%
zID2A+<$D3;F6Ms*hK2@)7u6m9{r%l8$@Kq5Bj1CB#r@26e-4!#h;Ms;K;VbFIQyT}
zADu57tXCeF^fYuSUdbFPbJ*h1>SVDZQ>M+jOK%D+mZ@lW->blD(;vn6Cp}FpB`NLD
z(!Os`8I;wnnT^@4%a$7jU02*+pK!9RUZUREz{vP9r_QTJ`=0%7n;(LlW$>yYko^Fo
cLjxnj(bc+z5=pa;06oIs>FVdQ&MBb@0C7ud+W-In

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/history.png b/platform/icons/src/vcs/history.png
index 889ab38795c3b939d4d51001a6558c807fb41514..a73b4e7d40553ff2552d4786fb8fcc9eca1b7a35 100644
GIT binary patch
delta 392
zcmV;30eAlS1AzpPNdcpgN<Dvq>iLh1jb7~guc)YaSwTam>E6R<4<!V6yaR2tc!lom
zVhXa=;sNpRKmTw;BdJM<g#kA>`&rf^P*p*WPeWb|Y_d&E9+(F4|1mI#zkK(3ArqP=
zMi2&if${$R`w8zDcomdoL>YbqRfF)#nq)W|B>w8-4+nfM00Jhi<4b=hF_=f?!9~{9
zC4*^kH9ZDKc~>sH2K@Q^@0($GF3+ET5WZL49Jt&+VBl{(a_t)vJ_Go9IS$`=_?qF*
zzyBB*B+k#ragdM!F}LqM{&elZYlfeH|1+FjF&RvQ_;;SXc?pz{!|R2oOX}aLsA*4p
z$!s2Q=g}(#MrkLWCx?75{ty)8-6to-9|M&CfYX5YmXN?we6cT3^3ndY&n2Anfa${<
zD8zH_uhYusZ-6YI8b)YJ{LerbfTDOal<nKv+6sv$1_}WSlIbu|1f~0kHUQ)tqzvVV
mM&nOvlzIUih?D?;00RIAe7I-o2AI?U0000<MNUMnLSTZO2fEV$

delta 384
zcmV-`0e}911o;DyNdcRYN<Dvs8t|V16I}Vv&b|JHv~9k+k{q9=yePxrC6gI!V{#d;
zKYYz_>&cs!@{;^oEDX58+0U{TfvO5}d>Zm%3?Lh9V)DQ=i2sj)LHy;r&kLE*G%<oO
z&<l+B@83^&$H1$gEF;SB8>kwDSJouM*&y*(AAdODa{&-AaUEYeiNSw7Di1EQt}Yo&
zi>v7|Fv`1f;WgmT-+$i>!*hB5{Dbhl>gK@Z{sF^o>yc~UnD80E&&zT61~9<>{QHlA
zLE`*;90v&*5Oe$9<4@Nfyk_|M_dmng6_dd<h<^td3qbieyk2;^r2d_Xn)bw(%;o`i
z9=%dvly>5Ia`@s8K|yrheR5L#F+lkbI1PAj2?;F47yAMwAMHQ;T*67u=*2#7pb*cw
zzfLQkzX7s<YVai_1}ss$8Oru;ZEc0b69a{S1<7<6D1y>`#25hf0tg^wsLe#^qn;Pw
eE+7{G1Q-C)O}e9(;~N410000<MNUMnLSTZ6!Myzd

diff --git a/platform/icons/src/vcs/history@2x.png b/platform/icons/src/vcs/history@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..d90cfadaf181443de6686cd9316dacd868362d47
GIT binary patch
literal 970
zcmV;*12z1KP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#Y)M2xRCwC#SN}^>Q53&#Z+rXhv{Gc7
zrl@FTh9+7#P!fU)3rQ;?AyoRU{R2Y%B=mDXM3B)B5)?*35(S}Ve!~>eG&8lbIlq6~
z+<flqeVscU%=y&0M+)JA&+gl~_k4Nho_o%H6vuIBKS@k}s;a6&7U+pR=NqFso^IeT
zovk<z!!<x5ARgcZOaMLu>Hr^tb-lk^xaNQm0>ddVJOSj3D9RhHQ93nBIi@Hiv#vPw
zGZy=8h;lj1w*e{vLz^N16!Jb~O*gJRBqqL^SLhb494@11TAG!l<1&+UG$W=JpK2fa
zmXwqkWlpyTeI1+Tx<|~pUW_||eHqZ~*Cz_|#hYzR)R<YFQYK|2lB;<cqMX!tN+PB=
zya{<`Bx01EqNhp?8DhCqA_LZ2K$?FG!`Xs4gs8qhnq#F%L`yH_ri%_mD3Le7vf-A|
zHwN+|)e3awOgdB7(kFsQ)R1N2MqqGO8K-j5vZJSxbQCd;!B8MNUq3_bFCK5=M=0g!
zbc&t^9eI#D7q)YN+6r(A3e4(cnj~C$f|d$4LNM0TipB@J5Z_#CTr35IL06fO9LRx?
zu97{+P)CB{C%!o%6RlCXVLCh993Z4s%VpyB=WE%Xd(+6f=*|5~-^j?7NFAd^k=g_l
zlYA1X6*6YlV$%z8fC-Eq-suoSQNS1@ug8O24i^4OsdXJ;J78XB9a_T;Bg5yw#d|f|
z3io~)AXRcoNDeeu?5up%<%Xli?FuZ&EG*k4M28Ru>Y%)e2FE5jzD(Z^qvjco$bycS
zLL4CVxMkQh#m!soAsb&@UP0e}o4xA|>Z1?`2$du3b+q+<_bl1i9gV}5p_aZO7seb5
zvK2ym0ijX7ZMfF$cDtIo`*HtI6UUbmgg5ZZ#5H#Hdz>yeF<wMugS%l^bcCHeEcL8D
zGHKF^M@*ARqvKOvjY{EEE96pg_-rez$7*LK+*%cF1>6CQ@U`P`sYLBsYCbX7@or9`
zlaEKFVvB9XV71v3ec{F41sQhySQV=t__Ln(MkJ8(0mq}+i9v9nfG{$ro35|VDM=%Q
z{?V{yjUsnKxRP-^%_tPwO0GVLUsPRPjdl}(J-exj&_2_F1L7T$t~j{G{}Ts-Gc@2s
srF>5u*ag)eB;kMO0JYzr=YItl0Nl&w`nwKsh5!Hn07*qoM6N<$f|nSyYybcN

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/history@2x_dark.png b/platform/icons/src/vcs/history@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..398bbb2f6fc1486516599182871554dd026b758d
GIT binary patch
literal 964
zcmV;#13UbQP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#W=TXrRCwC#S6xU{K@^_3d+*)7yRKTH
z#k#4XVw8!csG*P{1QiyNRzyOm^p=l4)@%6KLj)N;NKhCBNfd;d`4gr|rkS}`qN`^9
zuDkC4&U9vVVck|&_mV<*;A8GRbI&>7%$%7s7gI{nb_!+$YHDgWY|t!adfQ#^AFR^P
zAFntC%|$>VARgcVj04^Q>H)6<eZ9I-h<LdpfWRrx+y|WCF!sbmX&g}+iC~OWrX{<6
zYQb_123ZdM?SM+apufG3z=qf1r0wJKLq^8a2|i}dglHM&IOVaVIC?ZGP9gFN_1n5T
z-cL%(s#Fe_8+{)6MY|2g91kI#pgsp^@%iJz9C*t-ryVf}`ZA>`2p96wx$M+<Ebxj|
zBVo^?z@w}bJub~p=Ov|}0@Vw^LEjRFvjo%NxOY%YEX7!%Jez%(+a0Mv9>2)>SF60O
zzb;y<M(1<W#QN4=4rZd3eHQKv3>f*n5q2ylq$kB;7MwsJe{?>3h&mqM`%53Gkx*ue
zUI9MxAa_o$M*yz{*aZc{f?mNAE-g`q1A{P(^t7R|{w@@(FLnPu3_`$HnVcNRhAFkN
zH7Br*1L2ckeat2%D#8WbS>fgY6P;F4@g0wrvpwfZRnU)~->USsqNG9ESRIPiC8F5m
zBS@=OiN6=jdN~9{|Jfs<HZdFugb?I$yOGmwg;ynB@ewuw<D%8B%fDPD1|x9hX6?Gh
zpFZ@nQ*u&H4m2)Utdh;?f~`h31uNLhE?NZULk@v@I9|DdkqH_s)7QhWaf&iq@bN?r
zfhIuf(C8$cF<CYod~R_GefeqhtQ4p>atJUf$JAqQ@BQkYH(Nsnhb2R;y@O6ds1<B0
z<kkWv!^y6(I+x4kZ0_zOecwlEu$*AJ{vV^XsjJWJaJpFVB4!&{4Z}MO+%tRB#Bp~}
zOei*tP9zPFO?sjt)DEp$QnJlwUb4DP7OOy)Pti8Ob$}sQISyA!qKUaB*WUkfoR5))
zgm|)GUdlI_EeBYqf|6Mcb$+vO(rsVX2a4<q3A=~@4#l~r2Y^5UQxw>GF0J%wSRsV^
z(HQDVMuQZijmTPd4FUS1>gsB=nHku!n<|I4S#}8UA(E~*u*Clp0)ZLo_oGt2B?LAh
m4LeEr-x0vu{d@jLfB^s(vFV@hGz}yG0000<MNUMnLSTXop17s}

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/history_dark.png b/platform/icons/src/vcs/history_dark.png
index fc7d8430afd8c6a06833de97fc7f703cbd8effb0..6738a71ebe45719adffbfd572bc3d62fc0236057 100644
GIT binary patch
delta 443
zcmV;s0Yv`d1NsAyNq?M4L_t(|+G70w|35=lR~G{^*w1OqAb5N(n5~u6Eb#X8k0l>I
zf45^|V&?w)_wP4BKF))}yc{vt=GA^+gc|Ul0TW#L$I7|>7Qa!xx}pr9ro1S_;U$w9
zY-4g6u0MRuaO=sNm-3SQS}Y8>!PytWx`C>)GJG2HVhkV~Y=2_%z%+>ekAXq_<-5-d
znb0&bf-ukvj2A9kNO=91TR~Yyl;Jl}H3+Y)NrtmQ;;%mbaKPsRAYkG;zH}0Uc~l-;
zWL;e{m=;&lV_=kb<-%*gpTGaU8HVTb{P_prd)3W>%l!j}-PR-5zA@o5fS;G+@C{&q
z{rUGF1B1l*`F}VL5;7p>?t{mlu043o@bm9~hO;XsgJ}@|4lovg@^N?#c)Fzio&MKz
z6W>3(e|hK8YoDJ<JN@5r<l^@?A3trClj7F^$>R)z_m+^rV)=eHQ1#vEvrjmU^&G#S
z^#%&@?EhoD^7$Je3#bNPLSn!Y#hamQ-?FkYNIWr62sBubOoxFYDBVZ20U+lfWhh59
l8h=uw)C=H1qyzv27ywl@zt!lH??M0o002ovPDHLkV1fYX;Zgtq

delta 419
zcmV;U0bKt21L6aaNq>Y%L_t(|+G70w|35=lR~G{^*z`|>LGIEDFk2+NR^ZF`?@PY_
z_-V(?%*_4w@855n9P9^qI5}h9tZe?k2sPk811325i=A)54FUZ=83}PgSqV{w>uaYn
zXa;99Jbv*SgkK5^@M*Cy;0F61i5O(ah=>WwNs565v_f*gG=G#Y{`&ogg-mFg7(p25
z1;z^(E;N1q{a+hoGYlN*NQ1LM;@^J!bin5V24*H^E|9ZfHX|D%q@u^btm4Fl*MPtO
z{(b}cnFq$Vsh9<q1BKm@^H;tx;WL1fo&7K<z_0<3I4Cyo8o<NF8S~`D%lD67yaL;J
zZOs%g4dR1h0e={kad-^?#`8PP_ZJG^zkYcV=-kgAR2}~vId}Qnt9Ku^0;5m^B#$!;
z9_dAZX@g%k5|y7G-Uf^r3!`Uy41hws=cHT?gC&7#@FgU4!1(0Jlg&`J@1#kSzzik^
z3IPjJ0s;e|Ekz(&Mn<NO7z4mw0D-)`Jeb&KBJ@$u3mkA4kP83;3;^YFuG0p8a<u>e
N002ovPDHLkV1m;Zzu*7>

diff --git a/platform/icons/src/vcs/messageHistory.png b/platform/icons/src/vcs/messageHistory.png
index 9ac71e7ec590607127630e6d9388a47dc79b107f..28ca74c6bbc583d0c7b2ada8b87efbde92433379 100644
GIT binary patch
delta 474
zcmV<00VV!`2ABkpNPhvkNkl<Zc-mt8|NlP&I`EvlmqGCOTrgWJsafFd=O0TxeEx37
z#Kg?~_wV0tf_$6@g?Tw*uFb3czyeY<Y0@NA6BxC@ltxmM(EaBhuBpk0h&$>lG8|qq
znZY(Dm*@J!*WS0Dytx6C*J5G71Kxi6zE}mQSwmio0pw1bn14Jl4dVY}U=V-#?(;$>
zsM`O?*z^C@{}vV&-EZD~aaNWQW%vzL4Z<sHlHqKS_^XdU9Pqi|BLfpF+wrB77|f&c
z;DYPwlEJjNnjQnAyek)q0VhtJU<A?cEtA24_}9s@+%P<s=g&WgyjR^ExY~cfz~6f0
z+BYVAVZhJJaew&6!`BRd{{6?mAaQ;^j)T|?_z$!l6c#tW?V5c1=I#4mu043o@bm9~
zhO;XsgJ}@|&XYGUffmGJGk_831&~)X{(b+Fuc#~|`{v`Ptvioi`}|DW>Hn_77k`5I
za#H*nPnXocW5MA9IOo}t`kO%N@^{N*K49$BfPA+7jZ=2%^EW^iFs!f{z=$n8z=m2_
zG=o#>|Er~Wd61aF>H-{Liq&AEU4RRq7ywLt{~1UGObiqPMr_%c6aWxl0HNZ`YhK@`
QkpKVy07*qoM6N<$g4y8tcmMzZ

delta 708
zcmV;#0z3Vf1b_yRNPhyNNkl<Zc-m}JT}TvB6#i!B&gPPttE*WqVNhUUK}C_``Ve83
z75P|*5|M$1R3K4r_7-S{NP!wyJr_ZmB!omJq>_l`Lm0TR>r3u#uDh)}Gk0!hX4T!b
zE;IMc&pqe+IrmCJ2;6=6@;m-Fgis(!JUuQf_{7tWTZc5m^nXO-+HbbLw!O7(-$vfr
zWJL*?v8(U(qHc=*<>;Ris|kISr2__|+>YE7Fo_vm6zQD{I1~v5ISegVF6>%fiCyyf
zej+!|J<ZZlIb}R}H1Lm-(!Czk*PW#Qz;YypuXA&7s16~^N@t3Jg+_2~t&J3u&lb8Y
zNhr>9*sKT{Q-4#FHoNR1&saDd8qZ*0C3f~a%Rs+&xdx`ogSe(+^us8$ga%iBK{U&`
z^;|d<LaKmBYQNdskkn0+lgTJ@snCe~`1mITmwv(NbRyT~zP%XmM-+u2!$d2w`^j_r
znV6%c@jUdLLd?(qz_-~MFjd8Y{Ra^U1o{|L!5GhEV1H5*ZZtL68WkDv<ZnSF8pFuD
zAtVy3*tR_v9F7QShf2j%t4PWNVH@|j|AqZtU3COIDh^|Kco3mb&`zlGdeJ>F5-csr
zh9OKCWLicS3_@<YT5p@VleGK&e#}fyLME+8kCmgOWDlaTxS2>WTBFjPCV^AZZntBj
zm_i$8@PExK7>0q0@+zD?U5!;;B)u{;Tc)|rfc!GA-|6zD8(QrxbA^ISIcI7w!kO(}
zX};GJ)(vYbNz}>&OobDu3duT5o5#@Gp}~oX&$XdQysfaEcP!n{0<&DD)+mgT!OV_q
za~rMU^ZANDj*ZoLD=YEE`@X~arobSMlHFQC8$F84bU3*JPDSL+1$z5?n<!Z+JASG;
q)ne1W&9y_uxdBbrp=lca3NQdLo>k-Bcx8bA0000<MNUMnLSTXoR#^4`

diff --git a/platform/icons/src/vcs/messageHistory@2x.png b/platform/icons/src/vcs/messageHistory@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..5b23765858e327e65c5b451d432a4f4c8459d1c3
GIT binary patch
literal 968
zcmV;(12_DMP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#YDq*vRCwC#S6fdLK@^_Z-djp52^UKt
zn3kY`cq34tY9djCG4kLwMvMVse6c^k7=84?xB8|Sqs9k=2IC7R2BLz3NQ@;wP)g)d
zsTh@B7h1Zzo@uF;(w1HjUO36OvpchM&bQy5nX`*IjzjBd{6r_z-RkhSn|kgp>7T7?
zIt0xrKrJ92-~oICyaBWVUWEH<zg(L*fpCMsh0xpq?58khG8Hn9LMCA`Mq;~rUOi)T
zT>zCEVf-zi88DKP0%5`TLGz49Vfk)NF1t&U%M<c>(pL|S{_ztH2C-+shX%&KbN!>1
zN`__ML-#Sj>!1%Rh2UBeTr3nwkJps(D~j?d0iTCLGm4xG1$<OqsKzJtWqgT9Acn5z
zfUUt-n5+UAa33U>AFU|nXQayz6B1c}&fsrD`;>Ais@IhYTf0mYDA7W0`%A!RG$s(b
zgd7h7s&{B|ITD-=TSy<;?jgqOLAukImh`8~Bxp~en%DPvvIZ2aBY8-Ls1+CLxS<D1
zG<O4@o-Hj<VG=wX;~%@x)ZhmcX{;zO2ZOQTt0CDOn4ytCoslN-k$29*J`#?gMH(Y>
zG8JhHFkGH&4%mH&moAfvsCSP7udec}A>xf~*PH#VP$EO}EEQ6!3Q(4IJCaMq!XGxL
zI_V^YXXHUL;D1lLQr=+1vMgeJKIEOJ;Zj8A3S$w#(R{TBlJLBP_Neq{46;ZBj$CVr
z$>&qwAlW6Ysq6zCHWw|K^De+r;}QZ5bACBo0^%bT0<EyUQo|F|Y@|$&1+!&_BXhyW
z<5UQA0=m9TSlOR;SKPsWJKSjKtA$xCP%oqAKyPnv^w3o$!LvqKRz2OO5&7Po#Ue$T
zG$vz*n?_xx5idwK50_2x7NceP9a4s$c(RM0&J|QOboLLh+B_B3=55Ag?+-OE6r(YV
zl`~IT86ZqUS3STSF995(2!(gu1e&);C#MgXr>qPp;gL%vr05_QO*1wp&F2Dsx&apf
zqluK`SPBG<lva}`XWJOPrJA)l-Fk=9r3pA^>`LUFm_^bn!K_d8izprimf2x$`0C=R
z0+0=RM@Q5E<eLzxAs3c}IGO@05!UH+k>+88!GKmpfwlf9O;~}|Ca|Hve^-D)>ueDf
qfTgr%|7+{6zy<-l-oNL61Q-B4pS#{1q52j80000<MNUMnLSTZeL##aj

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/messageHistory@2x_dark.png b/platform/icons/src/vcs/messageHistory@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..988e13c6ed2b8061421822221ed67d22ac5c1151
GIT binary patch
literal 972
zcmV;-12g=IP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#Zb?KzRCwC#S4&J2Q51b|`fn*k5>QJa
zBn2@9sR{uUlqk^zV`SksMu-7o+}OBcVT>+ZnBd0fPBBJ}3xfvZMiYZYL5YCGDjI|m
z`BW;zPruU-of+>d6iZubKL{Ica^}9dZ{EFk&fNDI%yArAN#Vyjp!#~dPp|2|wZQ&+
zTf<&ZM*vlTEPxyE4e$!k3V0Um>*<-Q*b@jA2%HP*CZLkSm`PK}+zOe5#Tbb#4wq`m
zY(EJs*F*nnKqFu<AqIki?*#RjM`8I^bq2ddoxv0GdD4!1*L?klYPDkbj2C?v{m%6b
z8%r6MeGBFTfR}zBR06?sNN}-GAU#-K$S=vuq6B;%3alv777F;NI9G)aR}}IkB7qo8
zPXHVJpD<nqFyIbQF5h30&reO3AtoSl#R;uX2ij8PQdCn`AZ+c_Q@}(Ed2Bv`=H}+;
zLraRtbq`>>MxDWt;B3%D>TSD?7>^s39X-9ko-C7~qFfcP=gW9GFj!6MkP2WcD(rH;
zyPM29F2mci1=&hWf(K)?zY9$a^rCQmd70}l2n)Vy<E?=yCl;wvlO$g9%~@DSg5j5N
zePm3UB54M?i{q^U3xj#UriglTf4167k88s|*mkker-c$3lBX+CiZUCe=WIf9saQB|
zwyEMSLU>0W0v`Xq>Ay-ABbH?m<Mkqsi-ubf87qvG0A9?OZng;Pth8HMaZD=<m%zRY
zEfMp1-!ni~NmC;0K)cyaOPrn=m}*>1pkd5Ut6e~RB$7ZYEU(n(u}L;urALCnIK`2%
z;Nw9e3A_Mw4vm@E9~OJm!GBpD=+jptGq*uKU$h1^8qK1Sbwl&bdYD$-UHU=!j?MWZ
zMUpgP##RT7I`xAdpv(og4bg5!A@zNBgV*1DIAEb3bxeC}b$uUMb>@1U10ZXEpm<<2
z8ZnwU!?=loglRC<01VM45HcIC4uuT40(ssT9-rK8m@qNGgj+6^kWB~KX__(HXg)XV
zrwecjFdWNv9EkzHkgZj(H&Y|JX^J)592HiZUF~zuF%|{q8Z%Q#=loS4>xn2D212CL
z*?)ensQ|2nwWB@WBUv;IEJ#?d*Asmy&<Gn?T~kvNS`r49`%oI|kr^*_0;>%CcLpf5
u!V;DNm`cm`zqaBGtR{e0`uF^g00RK^XTT?8#US<o0000<MNUMnLSTXjKcaI0

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/messageHistory_dark.png b/platform/icons/src/vcs/messageHistory_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a7c5aa7b686182e3725fb65022d0783f21dd961d
GIT binary patch
literal 540
zcmV+%0^|LOP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzzDYzuRCwBA{Qv(y13K`Wyq7`n_*^hs
zE2&xF?dKm$K79Ue$Hc_U{rB(RZ-RWB2Zeb#Vy?}r{lEfJ)Ya96Y67P*n9@jU61xBV
z!!<P-5phR-MTWymCNtQ^<nmm9_}cr{lQ%bj@>(nmc);6F-xsR@HEYO=F@W4@6O#v~
zLHvIV4B{`}eO|}}Rr?<qJAOa=-@w42`^~#A&dM^P48MV@L3m|NGMo((fA#T)13njg
zWME=tJHB)hgLzaQTyR}oGME-u(_>(icjZDcKwn><5kyb8#R3k*zfO+jhT*w9fBr$_
zz3S$`)&2tp{?;SczA@no1AbnP!#5tjX87~(KL!Sg^Yd{W#Ad+%0<}N?<KyFRc=5fs
z{owJ7FV`NtX88H{Kf~D-lfg8If9J`Ymp}{Ru!R95%nKkO71LP%=HsU&cOJd6W0ZE{
zd3xyLF99LmJ#td~F;AD&e_+Ak0tN=PcqsSYO$H%`%M;$P@Bw3|2IRB-|BOqYzX7r=
zlNqqO09$x~483@fp&7&m8dM6R%gV~I8t@-Sm|``UXcyoDC<a`-c=102iGYcLLcoYE
eJCgzc0t^5io5qZ|Rc`M90000<MNUMnLSTaJn)%@X

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/not_equal.png b/platform/icons/src/vcs/not_equal.png
index ecef12ba3a39d12853b42ac9443582909560b9bb..b91d6e7e4516e093c98aaeb9ebd8793365d658f0 100644
GIT binary patch
literal 449
zcmV;y0Y3hTP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzV@X6oRCwBA{Qv(y10{fkScPYzeLa|2
zShoNF_kV}c;tif88E_`bhlPWer;m+`^UtsEKZ=m$n22&F8*3&z54R>WE9-Qf8OyJe
zWWbq7Zy`2L&U$8Mrgy);eQ!jUX9NY}`S`&9jLgi~P5AeZfm?u&;n$C!48MQ<h714y
z`<KCR;d(}J7;pg<0Byn0`}g;6hF@R5GB7eR0oCxM$o=~M9pM68;6j}LHZFcX&wqda
zdTC5swjG-qoMCV})ZK%XgTs^I|NkAhG{aqRBGCCi6BDXgtQ_nNK-(EUzj@2>@9#e>
zLGzEnV*Or77;tiNGO)3;BmDR47Xu5B{|^{w+&ny3ZT|K1C-yKn?qe^^$;W$>gPRi+
z^6GkvH@zh(DFYKt9V;8F@ZaBm@(F3i2*hLFb{eeg>{*PAj5mNub{a9M6vY4*R@Oci
rAo%n1cah=B?SF_dfRWPd3=m)d7>9#yf=hZ<00000NkvXXu0mjf0T9nI

literal 212
zcmeAS@N?(olHy`uVBq!ia0vp^JRr=$3?vg*uel1O%mREuT>k?B0|TkZd|~%Wpb3H{
zL4LsuTfT|vddIRQw>+PAb@I}XKX=_2n}Cuwo-U3d6>+WI=6nu{B8TO^et+~kUaTd6
zML2E_&o;kjMunTR)z7W%YW!&;)85s=pSJqh!%#t+z~{eX<5|7`uvjhK$9NoQ4uhww
KpUXO@geCx3K}pd7

diff --git a/platform/icons/src/vcs/not_equal@2x.png b/platform/icons/src/vcs/not_equal@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..ab7da6dd01e6b370d086c216619368b392fcd2f6
GIT binary patch
literal 921
zcmV;K17`e*P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#J4r-ARCwC#SItWmQ4~LO=ia$9^S(6u
z0|KKA-LwiND5CsG6Ib>hw2(ITu?s<i7Fn*uz{o|lDF_lNBxqxi<f<T$kf23~A6S0m
zd-HK;rgKLk?S1*4(+i>lmp5;?_nzN5_ji8xj1mL^{7qB-NdRxVTRZV*eA}zZV~;1>
za?PbtJD)k<##F`zaezV;fB=Lq#HD=mBL_fK^`f4L9WoLLAPB;D-I3bCyR#JmfYI;Q
zOtViq*OLiQ6td!^(*p$oM;bj<`?Z)+MRgsWD<E8_|G<rrm5KnE>27UcoL}Ik36xO?
ze1F!>Sa*tojtT&h?lzB^RO1|wdLSI9xAx|!_+w>=rMB%~&|xGK6Y-jAKn}?0pUuzC
zbrf2UWx11txMA6Xpi&ClFfjER1fCCzpFX!sRK<ed0YH<)QPq;2d#;OXIWPpE5CWO?
z4WOD9j(iq)UUnIp)hW<$lTysbjn)^JfSX20Jiy~*7)T07A#*aBYyb=qYldDDfYtd0
zK<1-U4g||i=KQxkz7@+r*(99qI#sX7WAEboswuKxzWQKorjMFcsb9>`vp3FzgF|C`
zQ$otv5FQz2TnpLcI?iRH5MixtZ26Y?2p}gHUCZ8^6l3)5dOY4N(=CbXdEUg=FY_<5
zbDbN2@B8HgcysOq!!y6d(RoNb-*<&&U$NG|mzT+(4^u5oyCMVLb|KT5!Nam!U0h~s
z3rio%=|y%{0bZSC7djxXSdIXwDz91rHb%~Mz2x%E)`3JEq>dM|OgarJ&Y@E85x=vU
zfkY}<a_Ek2=h6WdDq21hsCa(hgNdo9lwd6jpm+qJ7X+PK2Liuz9hmMsIT=eOTTE;;
zC~Cj!xTi@FyezmVpAKX!sK5Vo_W)j>J>I6rV$b7MsZi<gwi~Y<e%KXB6H{!$tCl7V
zm<?@}9g|Vn!f~%g)<qSq6+(JY@9UVx!#2xvz2U>7kLD@@V5+&X2BYrdl6acrYp^UF
z`+B5(WWh#*sC}IC8Vzqsf>iMwaqY<1leLNfm^#x~M>W<XNhbvg_4~bJS@$CUj>z9;
vsYpD7%FZTiv4!Yucrfn$|2U1>eh4rC4Xq(f${6ru00000NkvXXu0mjf)EB2<

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/remove@2x.png b/platform/icons/src/vcs/remove@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd89bed56bf242442d811634ecea20b93d6b1e0e
GIT binary patch
literal 1132
zcmV-y1e5!TP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$4oO5oRCwC#S4(RXQ53#&C-Y7-+1iB)
zR<m?rM#aY>!L;f|@lg=Om7+!0K9}Ni?W3a5jiOW(mrAOF6>G^KFcm>vBwJIPv`OaS
zcWzrrZR(7zB8UTrOzu7BJKsI`JQ67g0`@l_&i?ZApFnJ(jnUri%kc38a$>{a)52oF
zf#Kle8e}&x%8?@g!%oimOIcCYb6L*M0R6IavK1J>nmN$CNBXe}MtgfYVfaF|%#@<*
z%xg4Qy;`k!O*gk;@L3_6^BzZ5VtLK7Y*|%Vb83n;s<oo;c^P1oe;NU>y{nmK%Cc={
zC6mmAXja^o<yd}ne@|#6ppzzDvLRc-AS}Wp?9eMv4YSX*6D2KfF-28iXaFR^@ZFYU
zxQ>0@3zEQI8ahLyD{NpZFn~pvs$ukn5?DL%s2J1LEay@wU;&f3#1unEBoa&oFb9dZ
z`*QP0U@eWkA<`jTvLRc-AS_^J)($)#i<E>bFZLJxrk7=YP=YWnai$_4tOQO)_sT(H
z&$jO*@Seun5bco;>5>iE5(cm`z#NN|gsso#bH`IS)eF3K(sv{gYt$xL^-G1-Cy<z~
zo5OM-$6_;Kx0#BtBZ+4rO1|r5mS4C&wvZ1gY!-Yz)7PFvWn7S;HR0S&v~!+ae(7fM
zXZTW-Vf5+rv9=_pCaPjzN0PO3zT$F!F$`OZIt@RaI+~*X&`JWmLF}RC=Q{V`{K~Cj
z6kO?7#_`9KN9K@Vv$m2n$N9>uw~I@j1?`^t#6$-girI2n)=C7<t$MAN_#@MBWLGvl
zIbO{->y2dK`7A(*%@M3&&n6w{I=_{`>z!NEIA$JgB`MKq1HY}%9&~I-9yZQzAuzmS
zOPZ#dW*A9?UnJW!2XXQ;q$J+4#^o6Ge6(}JCL7o~OCm75eKQ6N&+De1G^x}y6&(%<
z=ldk(0MiYEj_H?Z4V@P{8Z$dA1{<4ff#EEw3Wj?&trH#2GLvRU9H-J-ORY?!b=9@I
zBHKTlIQT<}`mBKwTpRz2QC<@rbL+D=g~$;Y?uK(2y&YknKDpM~+sl5_{qCF|ddFJJ
z?2x7-5sx!qAQHHa?oCc40<Ur#*KwH-sR+A)P$~$!m}*EeNZE6nnN>IL&8u@-!(Ntj
zNSAI((N#tmz(P*&Jg}Wm0+{FLF~^g{Ufen7({&!;<gT0Px_N)WCPRCqL%L)mBB9Sj
z!Zhgj#HH{bB$|G}u&fagc8)uz6bW$Wm}*`94?;T}>5wkjknQX!$5j@9y*HGA^W=F2
z$+rVB9H9h-Anb0o>(+zF?Ui(4lOfwc^afTyiRK79autjn-cPkW5cvMt)wc)VE#_zW
y`y;(6iSw(dm_uvsJgh8v82$fi_D>S{CcpsO-U?L5<rhK#0000<MNUMnLSTZSrWQ2-

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/resetStrip.png b/platform/icons/src/vcs/resetStrip.png
index 922e80cacef97104d965493abbbe0ed648ca2aad..f688e4844b7ff217e215ce642d54893659bb1183 100644
GIT binary patch
delta 455
zcmV;&0XY8Q1J(nO8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00DSOL_t(|+N6`cOT$1I#_w{;CH*of6;V`N-1Hw15f|;~qEm3t&CyL<
z92_0Q|3F+iC<xlkO>l5k99=}k&Dudsn%tdFYf}0V+d>b19Dn!qy!Sr$9#u+_VVa&a
z>AG&~kb@(z+qth)DiN(ufIPSXTmNn7CvXOqfelnd5Q)wVB2bTf3#x!dWWgOcZF+Ed
zu&NmQ(}JnB^;!8824ef_W#SQ2#mIxW`QQZXH*a9)vt)G4iD8bDEm)SZu{QngV7b;|
zAdklPO##kzl7C8@4Xl*O&=;s-tz5rOR$6k8`36g|v5gd@ltc;<r$97~W=1ml+~$1c
z!SjM=A;hPW>IX|-*jp{XO&zz@fx_XS7LbLVbK1+%@?r5K426&PZx=uW;(31Gs^g|U
zt{Y5sRbu`6aSFW}g#~ylnjjDkRQF1X<iAjl&NPi&>_9Cl&kqt0Tc$y5J52-(?-qbE
xHz>*FI7w%WL;<Ez!jOItw%>vd`<;IU7yzkBijYQO%hdn?002ovPDHLkV1mt~&?5i<

delta 466
zcmcb{{E&HqWIZzj1A~Sxe=v}G7~m7)`v3p`u40$w>ZrDgpth<IedmOZ>JV4|cp!2K
zPC!QO)xj-Q!F45`K*9Fvkk0Cm_R66CdLM`yp!U|vkXE1}<pG^FQGGSOAJ66ddNJeo
zyR|?Czg|rI^?Kf~H;e0kKI{DV>&4%n5C8tS{qOgypHCY9{eJr6Zu<9Ei`K6y`t@?=
zuji9q9W{P=(&yjLN59{%{rz_3@3(7yJjnm|^~j3@(Wf@VzdB|6<3Yv0pLf^H58Jpf
z{NL{ne}BLG_v6aXr=8z#Cw#vZyKZU5zrSDBE{^~A`^~?<U;qCoUk3E8TuG2$Fhl*l
zdslBVT#X65nSWoj;_A(Ut3Yt~tkAWa*RD^g2r#XW11g>9>Eakt5trL@mG7_t55r#5
zw=-rkwHg{5|NqZ^_LNrX+OkRV?^2}e1Rl6?tXE#RB3*e-(c2T8%eMB2@vm5wvynri
zr1Qxe`JYT0umAnsX+MQSu~S7MvZ~6yZ@qWe-ivR3Ui`S^@XtBY%?nMp9Zs<_o|(6G
zyR>9iNxBqI=|$O-0n5^t#Rsh4p1)#^Ov;L1GFczm`TbgizRxPVbQtJ522WQ%mvv4F
FO#pXE{ulrN

diff --git a/platform/icons/src/vcs/resetStrip@2x.png b/platform/icons/src/vcs/resetStrip@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..68fd3c0283ebcaa09ad45bfa1b74a8964df6ae87
GIT binary patch
literal 817
zcmV-11J3-3P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!(@8`@RCwCtS3hVIQ5^o=|Jab)Y8AAp
zA|krEi8$!wP#Q;<40X{-T?7S(E*V4|s*XB{AY^ipHlesUih{e)v9X9twMon+mwV6e
zT`%e7-`%@QK*W$Q_wMrE_rBlXmnfWb`kOE1pA(SJ=SO{|15bgwGCaj%(YvY>GUOmo
z0`A0Js83+?)4)1#F3I9?J#Yp1lyviP1>6MQ1Bd&b^C8&r=jJ9UK&(|H=gt6Efi<8o
zG6#zHFH3M`JA;?NCh!(G6s)Wvi)Mjk;0dq-d;#7~A_qPI7lE%4^F#=q0}uTBdjlbW
z^?XG9dXSs16#B@87cTiRj(WZEuNMYFU>z_?)50CX8K-vJUAdO6tgcnEKl?0P@~uqP
z2WDn7luDVQlbOq?Ubm^bTR)MT-*VT#EmQ+vw}IOc`z`y|&x0PY44O)(!aabtE#lDl
zZ69kj9c}6O)@EsYp(bIdNYWd?WB-12K!8UsaW053*~~aw+CH+8FmVf=3K$}Q$sAv#
z>&mHECmzu*O#6u8GhkzA4tN3>m)V~(DLQ)n%#T+{$g10B4Xmy4J@u|X%>^BDf;Vw>
zK<<{mpL`vD7)gden4@c2-ZXX6RFzzv5o3(JrT%*Ee~63`oXq9o_zf4p1qovm(b4db
zlVNBW8N^MHvpvs=O&1@QyYtGA7P)5--mR7sU4{%EWPT2~C^yGxdu2DQ5`vqGm?%Tq
z$5h%PRo%0p(NLoWaJHWVC^7oAQzP4U68C5!)G!Qh?6lf40`^1T!g{;WMAK;|79cpd
zsdu@f1q8~l(-Wl1GOTF@_+ojWJ09Z~b3dPi2LcPkSh6pS_CPP6oB+;x#>n^a1n@Wl
z0#)FR6Qsb4Tj#qaI5(H+;fv(~QNEU`;oeAOy;v(a;&~uoG7cM>o=#DkS&0N_*j;eM
vtAfB;pn$-%#{bXK;R_R>{P+Kk{|GPukjuV3`wexz00000NkvXXu0mjf7{+_3

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/resetStrip@2x_dark.png b/platform/icons/src/vcs/resetStrip@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..133d1d6d510efeb5d875c03b92e80d3933cfd353
GIT binary patch
literal 818
zcmV-21I_%2P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!)Ja4^RCwCtSHFuBK@^_-oou`_(L=Bi
z#6ml*L?S8{7Kaw5)Z%QkQVW9$7B*LiSR`I?f{h4*l@Jc~IBcxELn}++{)od%a=Xdy
z&iKt{liMVl-Puh*#E>sDyF2fj@6EjTCMz+<$lv@(|D1qEqcQ1`3e<u7B0QB!#c$;q
zIdTyA4BSg=sLo*W6Tm0nR2JiDSKt!xJ?rGt3b+k?0S=GcXA#&5#$KDH0B$P@jx7RL
zfRDiP#4LFK=wc#MzWgA3c^UWs913$rn3aGf;02%q*O3KlvxtGOz&YSo!Z^MKE5PI6
zx;nN6@SaWBzadzg_2m)rZJ-?Nank2q(4HL=VB~dT9>~QaZyH3?)u;AWy%^!)Rp3?T
zI#4Xlkz7uX9ZWq++HIROciYFT&6<}lSDT^7E^s$tzNMi3F($w;G-4KVvDQ3b`94^C
z_R(&~QTD#ow$1a^mVl!?NN)kpgX`Lu0H0joTu>C5C}!!TdFIAO#=zw<v^GHi6*<0$
zEYag$nkgCEC6cs--b-L3G6sABl!?qwRAwD<ey+Z8U9ai6)Pik`_0;!ud7wi~unt-W
z<X+*z!?*E=k>D2aGNUTWO<h-sBFn^6DWQ}S-!!mi!4HoZ&PhGSkKcF!jFV7G5-J*Q
zGNNe;dKzIm$Z2oo_@s+Z)(7L(pDi-qA$+@CCpir%R*(iU;33@{$Mw@LDigw!@;#9v
z>Zw^Uh%EPfuq-)Q0HgacfD|LYcUr`@oy;|w3)M8u?>k*rM8N(Qc<|n~Iw(4w%mO$E
z)71fYvVc$;_G^MrTE-Qv5MQbl81$$3$2`g>umT|i-WRM3lUHDvPfP%#Lw&^ibOKl!
z0ii7L`x!#u^_|m$6kJ%C8{$i~0z7>UUBR`M$$M_gInu2_$YoWP$ozbc6sVC&fP&dM
wN4hKsodpsIbYuE=mOfvc0O`MfJN_fU0RLLMdYFPb8vp<R07*qoM6N<$g6`mX9{>OV

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/resetStrip_dark.png b/platform/icons/src/vcs/resetStrip_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..126d9af49bccfb4f17a942508140c3d5b55997d1
GIT binary patch
literal 455
zcmV;&0XY7NP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzX-PyuRCwB?le<a-K@^71WU`ZFldy(}
z*y$r!2@=6VOrO?DJ1Y?^#3m15qm8xND!846l|n#E5g)+L)(e>3%+8E|+}+@=n+s&%
zW0>1N=lpYq8DnUgmd~1WUH9)$fFrP%-q&iiC^zPU8n^{p!#0c)xBzRw0VYC5q6?D<
z^l!cgAAm(vKnI)+Jh*Oe7|ug2nA+1?zXVcki{;&COf@49;^u=Ba5#v-sa0rpZYG91
zPNgnHzUn<37qHw*87QLh;~)ZTrjlLwUDeufboFjvHH%A|os6^sa2Fe!4-aY5O2sJ<
zV^kK@T@9X2&!tqaTIqMpe}hl(WjFS35_Mp3SoS2X>|C-@j=JsjH>I?X_g_p1C<u6-
zKep<MB{6SOr5mOIfjEUxEqo}(G6aH&>fUIT{TKST^IVRu4jRVuWp?-liyX%$1;hUf
xKv`Ifs#QUD*%}f)BhC%UAQ=Ul_B;OwFaRFVjtcICNkISr002ovPDHLkV1k@jzoh^G

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripDown.png b/platform/icons/src/vcs/stripDown.png
index ed8a4d0568e1cb1f714ff456216caa9d4c257548..81b5d3cbec7f8151e4ba61ea6da4b79af23d0b3f 100644
GIT binary patch
delta 429
zcmV;e0aE_j1H1!}8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00CY}L_t(|+N6`aN&`U@hR^J{>uxRt8%-x-VdD#EO0gBhOR<WzZ(tW<
z5#K<twJ?REf*>e@2q}CD5ld@jGn?I+@!ybaZlf;bzy~`sXMg^g|IAsYwWdj8>bC{o
z_eZDZ!5!EDAIU_c(I6}1K^}Ml%iys)?nD-WB<BIlf;CX?j;*W$7ho0affsN9D&Rb=
z!A*5tbKcidDD37!T)TZQA7dy%9o%=9lRBJ$rBt9aQy|xM`T|l>5Qy5=;wN3d&Fvd*
zRqcJS<Qbc%JAXP~Nb5q$Tqq*?{tBoS2$B#S6yL5tv!Q2HN?}0`9bwxR6^kBup3||^
zi?G!m?*om^Q9GiQ!%Oy8HDAwmwU&HbKte!>@ZaZ1a@2sGz6A)3S};Y7TN+zg$v9Ix
zn)1>caLb~rqly+`WZdjd+f*v$NGg*BCCRZFs_sxOZzdZBxW$NbO;J2-l}-9P{|GPu
Xzv_qHo(x>z00000NkvXXu0mjfiU7Sw

delta 459
zcmV;+0W|)+1KI<S8Gi!+001a04^sdD0NYSZR7L;)|B7=&gL_(rcv3GzV1{~Bh<j8-
zQ(#0>U`0<~iF;H;Q(#0>V1#;8esoDiPhW?5Qbbc=L{nggdsB~pOon(;g?UtmdsKyZ
zQigX>iF{g)d`<iAt@`MgL{nh#&TRVVk@@C{`s<$h?4!!CUw`=BXZ`rw_v)hl`sn@n
z;r;vW`|Ygx<bnSC<@)E6uBB+{$xQm`nfvdp`|YXz`|SSt;{Nr-{{8i@s&eYeJ^0{n
z{`uXpp;zj~Gx*?m{{8g+_|*C3iTB%J_u5_Pz+3+N@U5d?{`=~zpH|KcdvE{%0338u
zPE!Eh-qirv)qlyzT-D9g*>F+S#=h0v*4fq8*OYkEU9hJB005FnL_t(|UTuoy4#F@P
zMGI>;+?~n<cX#*qe<HdMk~W0%<0j|iA{`E^Ip;qfg`(U-8NKkBoHR$tq8Tx>VT?nN
zEo6v=BnO85F>0&f<FzXgLgEQOq(o<Vyw9GkcB2`DheYU8+NJJz;EcXuKAC#Vc6x_3
zguK{#E|a>c?;(`LiP>kVm+L2#Zwd&NfTD{2@CL$J5=m9@o%;X)002ovPDHLkV1n|=
B{|f*B

diff --git a/platform/icons/src/vcs/stripDown@2x.png b/platform/icons/src/vcs/stripDown@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..f366a9b01016ef697f52c81cec761f4fe1937ada
GIT binary patch
literal 761
zcmV<V0tWqwP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!n@L1LRCwCtm%ne*KorNH<DX5^mTpL7
zMl1+1v2|buB!)6Xo%y+dL<Jj!y%Go^7A8RHf*1gG1_2Ta{{vFP0z;Li`QbRe<9pU6
zy(Er(b_ob!=_8+gckjM_@7=q^;GEOnyo`TVK($&;8*)wFpT>38>-Fev&FRA~fXA}^
z9lV(}urP<k&wwppN<{nApAt|3uRsxWB%=LJ_RUqmGT2rYx&p2$!nWm@xd?E;Yj9FN
zKLjtq3-Cz36MfHRSVq^(B&=_&YIu8eiG({V+wZ|`rEdeA2CGVPUjLmQxC<`J_71oN
zLZv?dYoMWQ&s$R-z!&QlgnQtD@_ba@yWk@D88hdH6!AfZ>%^1*cfldkOm+xooCbri
zHV6i!h`0%M!8h<VVfq(v0~`l;rUV>WStQSM5(Ti3QK!?R{Z^-TzS1z>HYzpQRnzp|
zv&k0+9&l|cmb_#Spln;VMTTL}UbB7w+_4>EjK?m%zWFKJS@7}68ZVU>QYVP<elMWb
zUYlCYHu-*^bk39Y&Cf>MdrLLUIn&$pu1V!ZAr>C#m=uOAHFUGCaRE&KWON*hmX=CX
zEPBLJJm7cx=>jP7K(?dVvdsvMxM_HRu?RIk4q2eMYCBZ`L;RV{0TI&xd!2<W*UAOd
z6C1l_SXUU=$pLnd1ARZB=I%cAdO<D$o@dkYN_kXQl5#6H1R=h@*Y&C0_H#O)QMv39
zcP#x7sN0asgw)-ZakXO7UM3HW+Btu)4(F@(G(4b85bcb0VcG-Z_VfgBHrD2pHw0|T
zUZ!0TwezPy6uC)znLJQH33441&vq^WVy>`}%>&9OTb6-3?@@`lxdfP4UD(LB3zW0K
rfC0xn{GX<wy(9s~fB*0JmjD9*x3Y#jj%;uW00000NkvXXu0mjfIsRPA

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripDown@2x_dark.png b/platform/icons/src/vcs/stripDown@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9832539a8ce549a7ef36571b2700676edcd5671
GIT binary patch
literal 757
zcmV<R0t)?!P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!mq|oHRCwCtm%DG&KoG{q=jT00L`Ol5
zXb>fWA{8~#6`@Mavmph7j)Xougb<<y1P$UOgi?V7;vpLT2PB|@BD!4e;q!TxZ>_zs
zmvij3!+{W%e)8^lclPtl&g|I|LeSs5tbbNOtJTUIa$eo<r9Esmo5|go(Tkk|cU1cu
zc)r`f$_y4i2A%+0A=^j)lz@ZaDX4*-LbhM1XEPNr57xDX&VqBAuyr+NCIUS03>;DY
zTi_9R2yUz2<g*7VEcsdR`0_&Liq#X#diOp!quQ^*Nf4{P3toZ+Eh{dJv*34l;HtLx
z7jRlzTwW1a1YfoE+*a>sZ){o+u7T@X|A4ypWqN}jDRaIn5pPtu4o?a2s~*{QwnGF9
z8ja%BQ8Xe=#3ir+K7&sg(?5cX;1IYnwFh3^Y>FW8G6itV)awmstJ9-l7_9`ymsiWi
zZK@LbzDu=wknI78bzFxm%c9M8ccuT~1~H3N5ld_Dik$^-?=FgZqnbNGjt>VBbvC=y
zX?H0Mhh%b|EUmq_(tdYz!$PoG()%_w_DQkuNYAD?=G@Tjc1;Rk^OMo@9GaV}Q>_*d
z=XfCO5Ay|3;(=mEv*X$c25~d+0CR%AKlWIlgl;=m03-ga_JE9Ogk0yCORZc%J#mpO
z<GRAaWDoGKJ%Aji_Qn<s22m*iLEzH-{sxWfO4i;=4MB{zAM``&cEgg+XKFM85}soo
z0zD0d+K{GcnN}-y+AHLN?RLpOtmFB*Jp&JD6J)z!U6}U3q&+hMf+yO7%7%ca>=nv_
zq+NasB$3-`uaE~SC_%nwqwkgyAm>UO#XO+Bvg25&^8wY_FD1an>e5EBEYQvZ3kE!Y
n?;lNLdszak|NiUvrvL*0S>TdpZWW1n00000NkvXXu0mjff-+qT

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripDown_dark.png b/platform/icons/src/vcs/stripDown_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..e45c994136bf0f193b8814da460b14bb351759b7
GIT binary patch
literal 442
zcmV;r0Y(0aP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzTuDShRCwB?lRrxXF&M_*B)#*le<&{E
z=IG)iF4|FCg@U>$&JH@el{(Z<py2A@qF_M~6hQ<BH@}0Q!E(LpT@s&^>-AsMgTC;C
zOY-JPo;U9?tu@UOh2Iw1?e^r<5_kaH;LA+Z>viHe5AwkaSOL%JxF2~0OwJQn0GnVj
z9rL^bH(&$ogEw#pYT!Dn!F^*(3o+DEC~OiZ&BEHr8HN(Hz+<{>>TnL0GlA-SnLN)O
z3P?pk5H>rX7sOYO4=lH83_h57#`nuzT`FgFAu|_+F?GHJ>INZ62#$*Hv|icRGb*L9
zAjghy98Q&rPrmQ=Ee#^-_NMzlV{_b#Y5nMy{Z-A6t39oym==%_2*c>#=P)^H#LmzH
z1ST!mBEc=Kt*m5{s~v55*$o8ebaz_QVH8_8dvgv|t3{H^W<g1E9fqpAR4h4G0l^sw
kp(#$rt+H8v=N|zE05+M3SoNAY#sB~S07*qoM6N<$f}fnd8~^|S

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripNull.png b/platform/icons/src/vcs/stripNull.png
index 504132cadbb6dc5db4c58b07640b73b6416e40c7..6adb60668edb329bcf6afb1cb8d9716135490fa4 100644
GIT binary patch
delta 478
zcmV<40U`d$1MLHl8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00EClL_t(|+N6^^O9Md=$7gTv5ig0k5TBraf%pJBu~CASR#xdOgb-g~
zW2J?am4ztg3z$N|#?o)0NoVV$5Q&J8-0j2JWD^oRl0X)IY=5yk|M}0%E|F5gAj|A_
zn9XL@wvEgo2Z+i>kW1vbSS%KdK9VdVd&mW%?q4B!WVWXRz4ChBMOKkCa;-(79|y|z
z4pP>^Wi2LK4(?CZB&7{4Y^u+ND6xQV0ZcyWnlIXd(`{wQdQ>7AgOM?>3H7{KDiX0a
zH>O`b9jqJ_kbimIz?>FoIIwLKhFquaKnO_<gQOVaD?z|MleYi!%jivJ{O!yja?}^b
z@#DvovR`Tm2q8dl-Yfx7AnG{Q0(YI^%uMBlbN(d-J;bAmA;dRc+wXV>5`zOjfTi3m
z>DJAM)Ae_BR>S$9cL-nxs8(w|$6-6>glSRv?<Fex%~uk-ErOH7VUZ94*4Mk2f`|VF
zl^t6TcSp;zS_?vhBaQ`$gbVmaLIhCRwg|-IHn>qMRDc=;D3%|vP8Vd*@BAmg06oZ-
Uth0TreE<Le07*qoM6N<$f{lvTbpQYW

delta 442
zcmV;r0Y(1p1IYuB8Gi!+001a04^sdD0MAfNR7L;)|3p(@igQFSLtuk@T84O1L{ngf
zdQ^yeREK+0g?UtodsK&cQbkW+hkH~-PhXFJOon(;gnCncbV-GHQigX>iF{g)d`(1C
zVEgW^@y=}e=$QHDiTdlF%CKLrs&cNSX!_`p`s}0k>Y}WlR)7Bc<><g$_~3Z{`sn)U
znfm9F{{8gn$xQzF;`{Hd`|YXz`|$qz?Ed}rv7uM3qhIREJ^AE;{`uYe?X3Rw#OlQ}
z_~38;_|*C3iTB%J_u5_k`|kex>iFGf{rTbj_}frzcXt2)02p*qPE!Dh-T>a!0NK^m
z+11ri)m+`y*?(}>*OYjUX!a2R005CmL_t(|UTus84#O}EMVn=9I%Eix$IQ%d|1-_a
zHl<ScWLfg_w>1SthJk2AAc~+O0@e_UiTFt_Z)VI?0ps6Oo$rC7%;2!;j_a*j%QPXR
zTnR;%-xkB!{N8)Mnn{`9ZN_%Y?hmZdSBxjqK={_CyEB%e#J7PhU_3q!QdId#_-7a|
k*N>=m6jIa^iiY-wH>XJtqd$o(_y7O^07*qoM6N<$g36!vbpQYW

diff --git a/platform/icons/src/vcs/stripNull@2x.png b/platform/icons/src/vcs/stripNull@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..8950fe4300ad360e14219bc2a59e7c1a58e1765d
GIT binary patch
literal 856
zcmV-e1E>6nP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!`bk7VRCwCtS3QdpK^T5__A8rY;|H<w
ztFW-}Kv7Vz5PyIQA)e<&q99x+SlNoX-(X{>s1dyrv9lM%!p6?Z#=<KE@h+F!&F;=P
zvo{lGH?y0~2Z%WEz+@&f&oj^azB7qN2!X%Zw0~MatJM<S%M=ZY6^bb1>n6n$iq{O?
zZZ{q@=5UBB6l)X~MTw%V5W#pD<5do(e4S08IS5$h<f8wSLQj#u;Kag-hM1g(fLq*F
zS<rJXLO!`@uPAQH>Sk>NPRdT%<YP<H0T)x`EjdJJPRSf_5$n>}Qi^;nO`dR|d+)*&
zyoXdGNQzjHFRLm9&AF@zhqB~VgGjM>9PVcj=sfwZDdrY=j+mgR&$!u+1-hPZ2*Cux
zFzSRs2$+!76!|kL`GDs`B#ntmXz_3*1?=7DLaAis3cwMDe&2)MR=+dw17>MQBEOy@
z7x{pBUx?7Sh(RI*wrxVWQp!ceb)dGV3T~|ere!|3bnx3zy7X}ddB`1TbNfYW@-;~Z
z*qcz~U9fBes%{xD#;_Shjbqi#=xeV=g9FGlg3ssc-#_Xaxsz~?XrJC~9AQq};3t2X
zApjRjb<5VlDcj(C{@D}zx4<#*hm9TQ@VNs&z90>q8OikBgS9#NTMmT)T>ND;4IN63
zeOl8HER-WyfSyO+qEo8xh9Qea9FE(WRR9G;Ff3}MvAj7xu5#kL+D9Os-%J67#*|^)
z#UW2J7cSm?qnv;Luu0_V$!f-*M8Pp)ujqn+)q2iC!o!yB5RE<Bbq5*RcmXW_A_r)V
z!>^w`@VsF9*J%(A?-ea4vdR!d^z`1258K=R)B@NZ#4?6^j~5`7p|}%@mZdU8sr@E$
zVA!AG2Wxu20uD$ESbxHMVbp=-e#Hb3oaht4vk4%R2#~5E?iWmfM=K{s#>y2N>UB4<
z-$V}3OAc&Hr=QKKPS4h|JtlKNI<i48j#`aAzu2BifKJ)j9+Opp^cJvto;|xW|3KvX
i<=&Y8{lDYi0t^6YcAQ$ij<PTS0000<MNUMnLSTYFfRS?m

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripNull@2x_dark.png b/platform/icons/src/vcs/stripNull@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..69aee30066d77a0a91c5e643bcd6c243f4f5dfc0
GIT binary patch
literal 856
zcmV-e1E>6nP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!`bk7VRCwCtS50dZK^T7bJDW7|gB}$R
z9y}_F9(oYZg2EDOZ6pdpZ-VsTRg6EtlNWD_wxX>>e}fQ2yyz)EKyQL*n`Ae;JL5a)
zY&yH0-Rvd-5eFWa%w*o@dB0{7g;ENCb146`fOfkbO|Kvv#2O+@`MQC4j(E%9IL>HM
zpMw)u5nBioQ9?8&A{fsm;u=Q-vCTHrIS5$g<k9>ELQ9ap;>1xToM>|%0&erLih?${
z2+{Lsyg}R&)y+DFoRoQ4=W8p1gUbo>hL|FCPQ~nV5!=GrN`ibVNgj*9=KYI>S?#5D
znFyL7j>uPK9iq;;ttp4J<z<Vi<nSasNFmU8@m-hfE%O>NK+>P1Vc8~VT6RDvp%4UN
zEARs#ls-z3zZ8lOcs+!|TGR;*p02on!$+!6Dw&xANJyaHcVTy@-x_*83u#LrzmXu1
z>VfciBtqdLhOrb_mI38TDHD~d4YflHP_0$KFpY<U&f^n!^jQjdz$4J);g3e0pNU6+
zy$N~V1=G@Dp;`t)2>cF1$N%;zG>)A|FBO&aeta2x-S`Nhe>Yxf+ULsBI*Y_j?)mE!
z0VG$co0bN4*#gh?E)2eRzz_Nz?dZwl!|uDTrjT=>Yw_CIbF9h9-*ZR=ko+&Bfg~l{
zI;$v{#hosLYuLsaNugumvTTgfaVND4AZH53O|2@dZca_=oY7tFsc_kGq<i}jz??En
zx;Vs57KKaq+S2_GPwG_cp0qI*KrsJ=*FcB|eAeq32kCxpQzC@5r|v~Z)s@KtSpK6L
zz#fNRKX<`({pnw)VKBZ|l#I+uQxKx}?!bdy&zo8Rvq4RLY<sc*p$(%uA#YnsQ<Sh*
zC<5d83_n<t_Hsl(IKbuw?}dXAh}+92fRfmp0+~$!Eh0eZg3&x@2|QgpePFFzv0!nr
z8nag@0(i-RWor1@n96&0mf0v40l{S*FOFIbpI>54B|t-VW}{da2yX$q=h?G6^AALB
iFZ0Iy@BbbD5nuojlA|xeG)=|;0000<MNUMnLSTZu_k=?L

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripNull_dark.png b/platform/icons/src/vcs/stripNull_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..959c379459a64784a027b983db2be04a2f632e37
GIT binary patch
literal 494
zcmV<K0TKR*P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzkV!;ARCwB?le<a-K@^7PlD%Y;uqzSq
z9pVM-#1vYjN@HO!7D9;ELJ%w@wPlEyM!{A=u*eH2*b15yK7m+hp%6DaJ2Re1CLzHk
z31r}7V0X@c{&VIGmQtcgR&3bMTCJwGZD1Za08};%RDjofK3^qcBv}IXfHI)Yp94i;
zZlnXfihAD#)_@Ffp+(U+4wUU3prL~sT1@sF+@0nmr5!D3YQTl4hm3C}vqvww=5k+f
zrmqayj&i4xXnMx$LOm~;wrykM=i$uO!OB4uSkMhDXpxQs(~P0GW3?R!At@m^%~-e^
z1nf~Xzdo?(Tz@}RN`f;N8}Sn_d#LQ!djdiTBslMufIuJtqKlSguKUkdpCI~1klZAc
z{)*6V!m<5<Igk*{0*00gH+Wb#?@PIN&Up*&|8hV8J|f?5jl2%aHfDvO^4}yX``r?T
zErOvuigAQMIM&=t!K2@T$_}kZx5q2eZ?VW=+cJ>rItXSYLI9La1EW;RL{7qp6rcnn
k3gxqK&;_3KIsXYT0G5WAEr!$&n*aa+07*qoM6N<$f+bYX&j0`b

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripUp.png b/platform/icons/src/vcs/stripUp.png
index 5e3c314ef9a98664db27fc390e7a101ef73b5e34..6c5c812ff161d9735ea0af21f61e9832a3afc159 100644
GIT binary patch
delta 425
zcmV;a0apIo1Goc_8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM00CM_L_t(|+N6>@OT<7B$7i!9Cifs%DRyFEX)Tr_2!bHKAcD2uKv0k<
z_z?tqF@>UnA3zI{`xJ**9@r^)ZFbj*<avo_;0Atdc4qgVnSa?KQc4)dCjJUomX&^9
zBYng!gwK%$$8q+QhCew$){}j_9wTgI1_j$kW|13YBU#^&gE-hE1A(j|pU4X`NcJMj
z;Nf&tQkrWCZ0zP-WIw*ooFy&~SwWtXEWA<^&8ZIPx|R!Y0j}%YTk`|B?@y;9AIRcx
zdL(|v*UKH*?td7WGxh~OgYPdFJl6-#MM-@7;+d2(5JF&pmy}gifo|6T!_a<9N-glh
z>KsVC%t8iBhqq)@H+xsRQgT`q;3(kx!N1QDpAm&}@)A&BxP&^3LRLS@f=7+!zV2L>
z0aX;ZJ6e{0z-lk+lPZ{I3%IB&L2%Gif?e03)mCc-s3JmuQVA^L)j1f)egqf*Wi5?C
T?bMTe00000NkvXXu0mjfU3R!L

delta 460
zcmV;-0W<!%1KR_T8Gi!+001a04^sdD0NYSZR7L;)|B7=&gL_(tdsHt&V1{~BhImp$
zQ(#0>V268DL{nggds9VEUxa#7esoDhQ(%XAQbbc=L{ngidsL5qOon(;g?Us(PhW+2
zQigX>iF{g)d`<iAt@`MgL{nh#&TRSSiTdoL`s<$h=#lu{XMf7DU;X&o_v)hl`sn@n
z;r;vW`|Yg$^~C=B<@)E6uBB+{$xQm`nfvdp`|YXz`|SSt;`!u({{8i@s&eYeJ^0{n
z{`uXpp;zj~Gx*?m{{8g+_|*C3iTB%J_u5_Pz+3+N@U5d?{`=~zpH|RZQ0f2x0338u
zPE!Eh-qirv)qlyx)yUOc*>KI(zSPy-*4a_k*OYk0#e$6h005IoL_t(|UTw?O62dSL
zhS5M1in|l3;qLDG{!c`*We6917n%9bY|ytTyru@8l@R7Xz)h6l3bdsBtp#=|V&sfi
z9AhPlL!u|k!wCkcuZEA;u1E+;Bo(AZXL-EOo~?GH8AbHJ^eOF9XFRY*ADB<3Hgm1T
zVGU3aTiaoBZoEA}S)7=Amh*D;p>op!R0Fyi`qLY%ni4s1w6&N30000<MNUMnLSTaO
C3;oyt

diff --git a/platform/icons/src/vcs/stripUp@2x.png b/platform/icons/src/vcs/stripUp@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..3c53f44014c7d99e4459bcb0c0282aae79029b48
GIT binary patch
literal 782
zcmV+p1M&QcP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!ut`KgRCwCtmpy0{K@`W|W<T#EF)6gr
z!_v++Wv~|02!bB560uQ?g<z*=B}&jn1Evz;5Jd~q+e8ZmLD0fd@QPsN<?c4wyW1K6
zv(BC4dAmEixsbwvA3J+9`}Xa7Z~il9aL#Ez+Z63{v+_Pztyb0Bo8TLGlJeLEa17k2
z*Xw*&4k+ybxC*wx7w|D=-aL2&954$mO)3SO@>&3|z`-$d4uO~Q<)VF^WDVQ_YqEb7
zJO`#SZi5$~BJWqh{Ye+$W$;G!Pk?*M*j=z7`|IG!M2c{vb-`({0gi)fN-ZqQ>t}Et
zgqa+uUtfqBsf_;61Si3Ja2PyR#u{?0xz{?-kdg2~Q6l<_ax7j4@TIzvDAxS#gmDpp
zb8<zH?0-rXBDdg>X(k7RGfw?}SnK!tl;Xr|S!{;vrz_#?+%$Qfljr~o8TtMWwOf8|
zvC=Ts8<kqZ^wmsK?7B7;OI~sWuyI+oMTTL}R<m>K)RFJR7*BG7mR8;-+B62c;l{%=
zyi_ivdMxG#J3VS`b*R<sP!M!UXGdLHd1oX>Kp5eiX;q=)npB<^&LSedNnyxRQ<s{8
z$N{E*HgFt^W@buMEPBLJA`onMHMZj@0@)5HmTg98<V_<2j71Fh&Wq2YoPAh3n^%;$
zYCF{dhWs;G18Pp&Z9n@l3wmN>wG4EHah)1qe`=r`^oA3DZ2rvbfalqCV6HsWm89Al
zn}YDS(nYP)-p&zxM&+_c+_Cgipe{qT7<HHCs8+<;(~7`f9_Ki=4{VLK7asxT0p+W+
zXv1hU$JtAEfRAy2@}z*p+S6JE;`(%Xp8K63p8)WG?PZF<6eP%XOx)YK91zb68`&bD
zRIOzh(0Pwa%+2M1iMI<I*;awF7Z@<$xVt|v59}p5VEp(0j(-U-082h^|0r+pdH?_b
M07*qoM6N<$g4XeFf&c&j

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripUp@2x_dark.png b/platform/icons/src/vcs/stripUp@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a7bbd397df958afda1db7f3fe117ffe77d311a27
GIT binary patch
literal 787
zcmV+u1MK{XP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!wMj%lRCwCtmpzCRK@`W|-hL+8JMRiD
zL@e!W541R}1&auR!dZ#fC|(M|PGcp?c{X}*SBW5^Xh3_L^8*Dz(8AK<io?oWl1(<r
z&iLPT634jNo!yIE;lPib&CI_2?|X0FOf=3p?Pi;zU2aC+2Wz#Oe0vRi0}oOjI|mMd
ztL1W;??`~u?t;sp4ZeVnW9H3+`@jOT;KHOruqCbq@Eq)onX?Z(6E6?j*GcBUO|UNd
z2f-7dOXDVZ3J!?-Rj@MYB)kY-iT*KgTN=9s7DWFgxHOR@9BEx}5^R9Opd#hMlDK{b
zXF-rjz@sY*vA-9NRz`oSgX7>m*bmmEu}v{n|JQY3Q+UDyMM2m<A;!kn0eq=yNetKg
zjfC;g182mFAkqJnT8Qj|MY^8s5Y9OD`$4te>r;w|7b4j-(NC|0vvbqrI98$n7BKR>
z4mBHIwexO8bB<K13DZ|Im15gAsaSH7J%EkNFb&c)jkfEp>+QF9h%ufdf)<xwC)(5o
zyWz&YQ@rFBQWb~u{Z5Y>+bwF;Tjcv)QrS@#m)~fK9te$a&XlsyvUPH&L$UCPr&AEH
z)X=4dAQHgT&jyxd(9BGUibaQ5iU<65S7AGjJdo{hVwie_LfjNQz*xj^?>zrFirI(t
z(|L;$mu;sCV2D2xIUvWh+4Qm>vrtb=td>DtVO%8#*zX+Z`n}<V?^{1I3ve8h_RP7%
zx{{Pzu^|Y4Rl2CPn(Z9UXXLsLam!E-fxHamWK><6qqSn3JtYtPp*Y8}ePAor-gpm4
z4@h5~r8bOuGtOSJ03IWN@`QkmwWqWS!t2AOdG59Rd<B62Z7-7trci=xOUJ#LOF;N+
zXd{~kq^vaz4Rzk360>s&(DC-rMz&QT?FAYPSoY2j%maH#0<{1B-|<fY1_1iYahMdL
RSV{l@002ovPDHLkV1gvwb1eV>

literal 0
HcmV?d00001

diff --git a/platform/icons/src/vcs/stripUp_dark.png b/platform/icons/src/vcs/stripUp_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..129a96a3ea7cddda4dda96109ffb4410917c38fe
GIT binary patch
literal 439
zcmV;o0Z9IdP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzSxH1eRCwB?lD$gAKoG}gvnD3@!C~tQ
zSc+JQr3ivx5&S3wYe9QKL89Oz9N3GELJA*13lU47z`|0n^GG(??5-2Z=Vd(uH}GS#
zGrRxH%nngX!8A7WSHSoE{PPBRN4!e-5?OFvch6|~lQU#9+o$U(!Y5`>v3+D7xka|J
z^#wUdgKaX9$OiI-JRzUiUKSbn=j)2nQcGfE1y4M>e0-6)LSzkj$g&7)O&rYiz_zVY
zKu8Dz=8fKlK$ebjkq=~XJUx;=<MVJwb$d?XOnnjKF!~N43>XL@YvS8ikEE7?loA7?
zrfix9^!pAtj`dqoZc!LF=Ro0Q9&=bZyd#sk`Fg#pl%P!kfdY(0|2{{0MpnuxOF)6~
z5_FctTtCWEB(3INcdp2Q8V1~-tST09?PYt`gu$Q#Lh4G80xXkY*DdIDO|1Ym2vDkk
hC!#qA)7Xyy0|3*jjkr|fnDGDr002ovPDHLkV1l;1x(xsT

literal 0
HcmV?d00001


From 29a4e1ba2bb402c54f0c490248247ea627669e18 Mon Sep 17 00:00:00 2001
From: Eugene Zhuravlev <jeka@intellij.com>
Date: Mon, 25 Feb 2013 13:13:33 +0100
Subject: [PATCH 118/354] external make: optionally suppress module rebuild on
 dependency change (IDEA-95844)

---
 .../options/CompilerOptionsPanel.form         | 20 +++++++++++++------
 .../options/CompilerUIConfigurable.java       |  5 +++++
 .../compiler/server/BuildManager.java         |  1 +
 .../CompilerWorkspaceConfiguration.java       |  1 +
 .../org/jetbrains/jps/api/GlobalOptions.java  |  1 +
 .../jps/incremental/BuildOperations.java      | 15 ++++++++++++--
 .../jps/incremental/ModuleBuildTarget.java    | 11 ++++++++--
 7 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form b/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form
index 729a320ebec4..976e2ed482a3 100644
--- a/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form
+++ b/java/compiler/impl/src/com/intellij/compiler/options/CompilerOptionsPanel.form
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="com.intellij.compiler.options.CompilerUIConfigurable">
-  <grid id="1663f" binding="myPanel" layout-manager="GridLayoutManager" row-count="10" column-count="3" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+  <grid id="1663f" binding="myPanel" layout-manager="GridLayoutManager" row-count="11" column-count="3" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
       <xy x="28" y="24" width="883" height="379"/>
@@ -10,7 +10,7 @@
     <children>
       <vspacer id="67edf">
         <constraints>
-          <grid row="9" column="0" row-span="1" col-span="3" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+          <grid row="10" column="0" row-span="1" col-span="3" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
         </constraints>
       </vspacer>
       <grid id="b341d" layout-manager="GridLayoutManager" row-count="2" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="1">
@@ -95,7 +95,7 @@
       </component>
       <component id="17126" class="javax.swing.JLabel" binding="myHeapSizeLabel">
         <constraints>
-          <grid row="7" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="2" use-parent-layout="false"/>
+          <grid row="8" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="2" use-parent-layout="false"/>
         </constraints>
         <properties>
           <text value="Compiler process heap size (Mbytes):"/>
@@ -103,7 +103,7 @@
       </component>
       <component id="a28b8" class="javax.swing.JTextField" binding="myHeapSizeField">
         <constraints>
-          <grid row="7" column="1" row-span="1" col-span="2" vsize-policy="0" hsize-policy="6" anchor="8" fill="0" indent="0" use-parent-layout="false">
+          <grid row="8" column="1" row-span="1" col-span="2" vsize-policy="0" hsize-policy="6" anchor="8" fill="0" indent="0" use-parent-layout="false">
             <preferred-size width="50" height="-1"/>
           </grid>
         </constraints>
@@ -111,7 +111,7 @@
       </component>
       <component id="5b86a" class="javax.swing.JLabel" binding="myVMOptionsLabel">
         <constraints>
-          <grid row="8" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="2" use-parent-layout="false"/>
+          <grid row="9" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="2" use-parent-layout="false"/>
         </constraints>
         <properties>
           <text value="Additional compiler process VM options:"/>
@@ -119,7 +119,7 @@
       </component>
       <component id="b5547" class="javax.swing.JTextField" binding="myVMOptionsField">
         <constraints>
-          <grid row="8" column="1" row-span="1" col-span="2" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
+          <grid row="9" column="1" row-span="1" col-span="2" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
             <preferred-size width="150" height="-1"/>
           </grid>
         </constraints>
@@ -149,6 +149,14 @@
           <text value="(only works while not running / debugging)"/>
         </properties>
       </component>
+      <component id="4b44" class="javax.swing.JCheckBox" binding="myCbRebuildOnDependencyChange" default-binding="true">
+        <constraints>
+          <grid row="7" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="3" anchor="8" fill="0" indent="2" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Rebuild module on dependency change"/>
+        </properties>
+      </component>
     </children>
   </grid>
 </form>
diff --git a/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java b/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java
index 57e1ad71c8f7..1119311d695e 100644
--- a/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java
+++ b/java/compiler/impl/src/com/intellij/compiler/options/CompilerUIConfigurable.java
@@ -55,6 +55,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura
   private JTextField myVMOptionsField;
   private JLabel myHeapSizeLabel;
   private JLabel myVMOptionsLabel;
+  private JCheckBox myCbRebuildOnDependencyChange;
 
   public CompilerUIConfigurable(final Project project) {
     myProject = project;
@@ -84,6 +85,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura
     myCbUseExternalBuild.setSelected(workspaceConfiguration.USE_COMPILE_SERVER);
     myCbEnableAutomake.setSelected(workspaceConfiguration.MAKE_PROJECT_ON_SAVE);
     myCbParallelCompilation.setSelected(workspaceConfiguration.PARALLEL_COMPILATION);
+    myCbRebuildOnDependencyChange.setSelected(workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE);
     myHeapSizeField.setText(String.valueOf(workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE));
     final String options = workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS;
     myVMOptionsField.setText(options == null? "" : options.trim());
@@ -115,6 +117,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura
     workspaceConfiguration.USE_COMPILE_SERVER = myCbUseExternalBuild.isSelected();
     workspaceConfiguration.MAKE_PROJECT_ON_SAVE = myCbEnableAutomake.isSelected();
     workspaceConfiguration.PARALLEL_COMPILATION = myCbParallelCompilation.isSelected();
+    workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE = myCbRebuildOnDependencyChange.isSelected();
     try {
       workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE = Integer.parseInt(myHeapSizeField.getText().trim());
     }
@@ -173,6 +176,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura
     isModified |= ComparingUtils.isModified(myCbUseExternalBuild, workspaceConfiguration.USE_COMPILE_SERVER);
     isModified |= ComparingUtils.isModified(myCbEnableAutomake, workspaceConfiguration.MAKE_PROJECT_ON_SAVE);
     isModified |= ComparingUtils.isModified(myCbParallelCompilation, workspaceConfiguration.PARALLEL_COMPILATION);
+    isModified |= ComparingUtils.isModified(myCbRebuildOnDependencyChange, workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE);
     isModified |= ComparingUtils.isModified(myHeapSizeField, workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE);
     isModified |= ComparingUtils.isModified(myVMOptionsField, workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS);
 
@@ -211,6 +215,7 @@ public class CompilerUIConfigurable implements SearchableConfigurable, Configura
   private void updateExternalMakeOptionControls(boolean enabled) {
     myCbEnableAutomake.setEnabled(enabled);
     myCbParallelCompilation.setEnabled(enabled);
+    myCbRebuildOnDependencyChange.setEnabled(enabled);
     myHeapSizeField.setEnabled(enabled);
     myVMOptionsField.setEnabled(enabled);
     myHeapSizeLabel.setEnabled(enabled);
diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
index c37fd886da48..e16b3d91c4c1 100644
--- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
+++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
@@ -827,6 +827,7 @@ public class BuildManager implements ApplicationComponent{
       cmdLine.addParameter("-D"+ GlobalOptions.GENERATE_CLASSPATH_INDEX_OPTION +"=" + shouldGenerateIndex);
     }
     cmdLine.addParameter("-D"+ GlobalOptions.COMPILE_PARALLEL_OPTION +"=" + Boolean.toString(config.PARALLEL_COMPILATION));
+    cmdLine.addParameter("-D"+ GlobalOptions.REBUILD_ON_DEPENDENCY_CHANGE_OPTION + "=" + Boolean.toString(config.REBUILD_ON_DEPENDENCY_CHANGE));
 
     if (Boolean.TRUE.equals(Boolean.valueOf(System.getProperty("java.net.preferIPv4Stack", "false")))) {
       cmdLine.addParameter("-Djava.net.preferIPv4Stack=true");
diff --git a/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java b/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java
index 89fdd636d344..0445ab0cd742 100644
--- a/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java
+++ b/java/compiler/openapi/src/com/intellij/compiler/CompilerWorkspaceConfiguration.java
@@ -42,6 +42,7 @@ public class CompilerWorkspaceConfiguration implements PersistentStateComponent<
   public boolean PARALLEL_COMPILATION = false;
   public int COMPILER_PROCESS_HEAP_SIZE = DEFAULT_COMPILE_PROCESS_HEAP_SIZE;
   public String COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS = DEFAULT_COMPILE_PROCESS_VM_OPTIONS;
+  public boolean REBUILD_ON_DEPENDENCY_CHANGE = true;
 
   public static CompilerWorkspaceConfiguration getInstance(Project project) {
     return ServiceManager.getService(project, CompilerWorkspaceConfiguration.class);
diff --git a/jps/jps-builders/src/org/jetbrains/jps/api/GlobalOptions.java b/jps/jps-builders/src/org/jetbrains/jps/api/GlobalOptions.java
index d772b3c6c1b4..67073eb67b94 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/api/GlobalOptions.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/api/GlobalOptions.java
@@ -25,4 +25,5 @@ public interface GlobalOptions {
   String GENERATE_CLASSPATH_INDEX_OPTION = "generate.classpath.index";
   String COMPILE_PARALLEL_OPTION = "compile.parallel";
   String COMPILE_PARALLEL_MAX_THREADS_OPTION = "compile.parallel.max.threads";
+  String REBUILD_ON_DEPENDENCY_CHANGE_OPTION = "rebuild.on.dependency.change";
 }
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
index c924d6d5e345..25effec23dca 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
@@ -22,10 +22,13 @@ import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.builders.impl.BuildOutputConsumerImpl;
 import org.jetbrains.jps.builders.impl.BuildTargetChunk;
 import org.jetbrains.jps.builders.impl.DirtyFilesHolderBase;
+import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
 import org.jetbrains.jps.builders.logging.ProjectBuilderLogger;
 import org.jetbrains.jps.builders.storage.SourceToOutputMapping;
 import org.jetbrains.jps.cmdline.ProjectDescriptor;
 import org.jetbrains.jps.incremental.fs.BuildFSState;
+import org.jetbrains.jps.incremental.messages.BuildMessage;
+import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.incremental.messages.DoneSomethingNotification;
 import org.jetbrains.jps.incremental.messages.FileDeletedEvent;
 import org.jetbrains.jps.incremental.storage.BuildDataManager;
@@ -48,17 +51,25 @@ public class BuildOperations {
     final ProjectDescriptor pd = context.getProjectDescriptor();
     final Timestamps timestamps = pd.timestamps.getStorage();
     final BuildTargetConfiguration configuration = pd.getTargetsState().getTargetConfiguration(target);
-
+    boolean isTargetConfigChange = false;
     if (context.isProjectRebuild()) {
       FSOperations.markDirtyFiles(context, target, timestamps, true, null, null);
       pd.fsState.markInitialScanPerformed(target);
       configuration.save();
     }
-    else if (context.getScope().isRecompilationForced(target) || configuration.isTargetDirty() || configuration.outputRootWasDeleted(context)) {
+    else if (context.getScope().isRecompilationForced(target) ||
+             (isTargetConfigChange = configuration.isTargetDirty()) ||
+             configuration.outputRootWasDeleted(context)) {
       initTargetFSState(context, target, true);
       IncProjectBuilder.clearOutputFiles(context, target);
       pd.dataManager.cleanTargetStorages(target);
       configuration.save();
+
+      if (isTargetConfigChange && ModuleBuildTarget.REBUILD_ON_DEPENDENCY_CHANGE && JavaModuleBuildTargetType.PRODUCTION.equals(target.getTargetType())) {
+        final String moduleName = ((ModuleBuildTarget)target).getModule().getName();
+        context.processMessage(new CompilerMessage("", BuildMessage.Kind.INFO, "Rebuilding module \"" + moduleName + "\" because of dependencies change"));
+      }
+
     }
     else if (!pd.fsState.isInitialScanPerformed(target)) {
       initTargetFSState(context, target, false);
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java
index e27534b98d40..2ae917dcf319 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java
@@ -22,6 +22,7 @@ import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.ProjectPaths;
+import org.jetbrains.jps.api.GlobalOptions;
 import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider;
 import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
@@ -50,6 +51,9 @@ import java.util.Set;
  * @author nik
  */
 public final class ModuleBuildTarget extends JVMModuleBuildTarget<JavaSourceRootDescriptor> {
+  public static final Boolean REBUILD_ON_DEPENDENCY_CHANGE = Boolean.valueOf(
+    System.getProperty(GlobalOptions.REBUILD_ON_DEPENDENCY_CHANGE_OPTION, "true")
+  );
   private final JavaModuleBuildTargetType myTargetType;
 
   public ModuleBuildTarget(@NotNull JpsModule module, JavaModuleBuildTargetType targetType) {
@@ -169,10 +173,13 @@ public final class ModuleBuildTarget extends JVMModuleBuildTarget<JavaSourceRoot
   }
 
   private int getDependenciesFingerprint() {
-    final JpsModule module = getModule();
-
     int fingerprint = 0;
 
+    if (!REBUILD_ON_DEPENDENCY_CHANGE) {
+      return fingerprint;
+    }
+
+    final JpsModule module = getModule();
     JpsJavaDependenciesEnumerator enumerator = JpsJavaExtensionService.dependencies(module).compileOnly();
     if (!isTests()) {
       enumerator = enumerator.productionOnly();

From eaad3b7de5187c184bc69655578b4431ca323b98 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Mon, 25 Feb 2013 16:15:22 +0400
Subject: [PATCH 119/354] Spring template icon restored

---
 platform/util/src/com/intellij/openapi/util/IconLoader.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/platform/util/src/com/intellij/openapi/util/IconLoader.java b/platform/util/src/com/intellij/openapi/util/IconLoader.java
index d26ff247cea4..04872b078ef2 100644
--- a/platform/util/src/com/intellij/openapi/util/IconLoader.java
+++ b/platform/util/src/com/intellij/openapi/util/IconLoader.java
@@ -347,6 +347,11 @@ public final class IconLoader {
     public int getIconHeight() {
       return getRealIcon().getIconHeight();
     }
+
+    @Override
+    public String toString() {
+      return myUrl.toString();
+    }
   }
 
   private static final class MyImageIcon extends ImageIcon {

From e96f9b48da4e7577f61d007f250a5223b51099ea Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Mon, 25 Feb 2013 16:30:01 +0400
Subject: [PATCH 120/354] winp library updated to version 1.17 and patched to
 extract dll file to the temp directory by default (to avoid unversioned file
 under 'lib' directory)

---
 .idea/libraries/winp.xml          |   4 ++--
 build/scripts/libLicenses.gant    |   2 +-
 lib/src/winp-1.16-patched-src.zip | Bin 6481 -> 0 bytes
 lib/src/winp-1.17-patched-src.zip | Bin 0 -> 17906 bytes
 lib/winp-1.16-patched.jar         | Bin 17342 -> 0 bytes
 lib/winp-1.17-patched.jar         | Bin 0 -> 27960 bytes
 6 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 lib/src/winp-1.16-patched-src.zip
 create mode 100644 lib/src/winp-1.17-patched-src.zip
 delete mode 100644 lib/winp-1.16-patched.jar
 create mode 100644 lib/winp-1.17-patched.jar

diff --git a/.idea/libraries/winp.xml b/.idea/libraries/winp.xml
index ca5008ccc110..6e23b6ef4581 100644
--- a/.idea/libraries/winp.xml
+++ b/.idea/libraries/winp.xml
@@ -1,11 +1,11 @@
 <component name="libraryTable">
   <library name="winp">
     <CLASSES>
-      <root url="jar://$PROJECT_DIR$/lib/winp-1.16-patched.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/winp-1.17-patched.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES>
-      <root url="jar://$PROJECT_DIR$/lib/src/winp-1.16-patched-src.zip!/" />
+      <root url="jar://$PROJECT_DIR$/lib/src/winp-1.17-patched-src.zip!/" />
     </SOURCES>
   </library>
 </component>
\ No newline at end of file
diff --git a/build/scripts/libLicenses.gant b/build/scripts/libLicenses.gant
index e998a02881f5..853e8e76af1a 100644
--- a/build/scripts/libLicenses.gant
+++ b/build/scripts/libLicenses.gant
@@ -235,7 +235,7 @@ libraryLicense(name: "TestNG", version: "5.7 snapshot", license: "Apache 2.0", u
 libraryLicense(name: "Trilead SSH", libraryName: "trilead-ssh2", version: "build 213", license: "BSD style (see LICENSE.txt in trilead.jar)", url: "http://www.trilead.com/SSH_Library/")
 libraryLicense(name: "Trove4j", version: "1.1 (with patches by JetBrains)", license: "LGPL", url: "http://trove4j.sourceforge.net/", licenseUrl: "http://trove4j.sourceforge.net/html/license.html")
 libraryLicense(name: "Velocity", version: "1.7", license: "Apache 2.0", url: "http://velocity.apache.org/", licenseUrl: "http://velocity.apache.org/index.html")
-libraryLicense(name: "winp", version: "1.16 (patched)", license: "MIT", url: "http://java.net/projects/winp", licenseUrl: "http://opensource.org/licenses/mit-license.php")
+libraryLicense(name: "winp", version: "1.17 (patched)", license: "MIT", url: "http://java.net/projects/winp", licenseUrl: "http://opensource.org/licenses/mit-license.php")
 libraryLicense(name: "Xalan", libraryName:"Xalan-2.7.1", version: "2.7.1", license: "Apache 2.0", url: "http://xml.apache.org/xalan-j/", licenseUrl: "http://xml.apache.org/xalan-j/")
 libraryLicense(name: "Xerces", version: "2.9.1", license: "Apache 2.0", url: "http://xerces.apache.org/xerces2-j/", licenseUrl: "http://xerces.apache.org/xerces2-j/")
 libraryLicense(name: "XML Commons (xml-apis.jar, resolver.jar)", version: "", license: "Apache 2.0, W3C Software License , public domain", url: "http://xml.apache.org/commons/", licenseUrl: "http://xml.apache.org/commons/licenses.html")
diff --git a/lib/src/winp-1.16-patched-src.zip b/lib/src/winp-1.16-patched-src.zip
deleted file mode 100644
index fb96ffb2ea2a52c3d9a493ceeca6b9627bc5192b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6481
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

diff --git a/lib/src/winp-1.17-patched-src.zip b/lib/src/winp-1.17-patched-src.zip
new file mode 100644
index 0000000000000000000000000000000000000000..02f7972bc776c7e0d0210c77c7d013ae85b5c597
GIT binary patch
literal 17906
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
C4Kq#v

literal 0
HcmV?d00001

diff --git a/lib/winp-1.16-patched.jar b/lib/winp-1.16-patched.jar
deleted file mode 100644
index 36dca5299f50d6907cc2bdd178ff465b77d0c641..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17342
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
RK=}1y{w4Wv6Zrk<{{Ybe7P<fc

diff --git a/lib/winp-1.17-patched.jar b/lib/winp-1.17-patched.jar
new file mode 100644
index 0000000000000000000000000000000000000000..21a670e11abae21cac37a0caf691461edac6a8fd
GIT binary patch
literal 27960
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

literal 0
HcmV?d00001


From 56f5db42ba6a0b88653a444a1d7f606595801f00 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Mon, 25 Feb 2013 16:00:24 +0400
Subject: [PATCH 121/354] [hg] Let tests inherit from LightPlatformTestCase

Mercurial integration seems to connect with the platform very tightly,
and writing isolated module tests independent from the platform seems
to be very painful (and the principle is doubtful itself anyway).

* Therefore let hg tests inherit from LightPlatformTestCase.
* Create HgPlatformTest as the base class for all Mercurial tests,
  remove HgLightTest as it is not needed anymore.
* Adapt HgGetDiffForDirTest for new base class.
* Remove setUp and tearDown methods, since they are empty.
  These methods from the parent class are called by JUnit anyway.
---
 .../testSrc/hg4idea/test/HgLightTest.java     | 109 ------------------
 .../testSrc/hg4idea/test/HgPlatformTest.java  |  95 +++++++++++++++
 .../test/diff/HgGetDiffForDirTest.java        |  32 ++---
 3 files changed, 103 insertions(+), 133 deletions(-)
 delete mode 100644 plugins/hg4idea/testSrc/hg4idea/test/HgLightTest.java
 create mode 100644 plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java

diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgLightTest.java b/plugins/hg4idea/testSrc/hg4idea/test/HgLightTest.java
deleted file mode 100644
index 12d7ae31add1..000000000000
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgLightTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2000-2013 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 hg4idea.test;
-
-import com.intellij.dvcs.test.MockProject;
-import com.intellij.dvcs.test.MockVirtualFile;
-import com.intellij.openapi.application.PluginPathManager;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.io.FileUtil;
-import org.junit.After;
-import org.junit.Before;
-
-import java.io.File;
-import java.io.IOException;
-
-import static com.intellij.dvcs.test.Executor.*;
-import static hg4idea.test.HgExecutor.hg;
-import static junit.framework.Assert.assertTrue;
-import static junit.framework.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-
-/**
- * @author Nadya Zabrodina
- */
-public class HgLightTest {
-
-  //private static final String USER_NAME = "John Doe";
-  //private static final String USER_EMAIL = "John.Doe@example.com";
-
-  /**
-   * The file system root of test files.
-   * Automatically deleted on {@link #tearDown()}.
-   * Tests should create new files only inside this directory.
-   */
-  protected String myTestRoot;
-
-  /**
-   * The file system root of the project. All project should locate inside this directory.
-   */
-  protected String myProjectRoot;
-
-  protected MockProject myProject;
-  protected HgTestPlatformFacade myPlatformFacade;
-
-  @Before
-  public void setUp() {
-    assumeTrue(false);
-    try {
-      myTestRoot = FileUtil.createTempDirectory("", "").getPath();
-    }
-    catch (IOException e) {
-      fail("Can not start test case!\n");  //todo change
-    }
-    cd(myTestRoot);
-    myProjectRoot = mkdir("project");
-    myProject = new MockProject(myProjectRoot);
-    myPlatformFacade = new HgTestPlatformFacade();
-    cd(".hg");
-    File pluginRoot = new File(PluginPathManager.getPluginHomePath("hg4idea"));
-    String pathToHgrc = "testData\\repo\\dot_hg";
-    File hgrcFile = new File(new File(pluginRoot, FileUtil.toSystemIndependentName(pathToHgrc)), "hgrc");
-    File hgrc = new File(new File(myProjectRoot, ".hg"), "hgrc");
-    try {
-      FileUtil.copy(hgrcFile, hgrc);
-    }
-    catch (IOException e) {
-      e.printStackTrace();
-      fail("Can not copy hgrc file.");
-    }
-    assertTrue(hgrc.exists());
-  }
-
-
-  @After
-  public void tearDown() {
-    if (myTestRoot != null) {
-      FileUtil.delete(new File(myTestRoot));
-    }
-    if (myProject != null) {
-      Disposer.dispose(myProject);
-    }
-  }
-
-  protected MockVirtualFile createRepository(String rootDir) {
-    initRepo(rootDir);
-    return new MockVirtualFile(rootDir);
-  }
-
-  private static void initRepo(String repoRoot) {
-    cd(repoRoot);
-    hg("init");
-    touch("file.txt");
-    hg("add file.txt");
-    hg("commit -m initial");
-  }
-}
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
new file mode 100644
index 000000000000..af5cad92bb72
--- /dev/null
+++ b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2000-2013 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 hg4idea.test;
+
+import com.intellij.openapi.application.PluginPathManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.testFramework.LightPlatformTestCase;
+
+import java.io.File;
+import java.io.IOException;
+
+import static com.intellij.dvcs.test.Executor.cd;
+import static com.intellij.dvcs.test.Executor.touch;
+import static hg4idea.test.HgExecutor.hg;
+
+/**
+ * The base class for tests of hg4idea plugin.<br/>
+ * Extend this test to write a test on Mercurial which has the following features/limitations:
+ * <ul>
+ *   <li>This is a {@link LightPlatformTestCase}, which means that IDEA [almost] production platform is set up before the test starts.</li>
+ *   <li>Project base directory is the root of everything. It can contain as much nested repositories as needed,
+ *       but if you need to test the case when hg repository is <b>above</b> the project dir, you need either to adjust this base class,
+ *       or create another one.</li>
+ *   <li>Initially one repository is created with the project dir as its root. I. e. all project is under Mercurial.</li>
+ * </ul>
+ *
+ * @author Kirill Likhodedov
+ */
+public abstract class HgPlatformTest extends LightPlatformTestCase {
+
+  protected Project myProject;
+  protected VirtualFile myProjectRoot;
+  protected VirtualFile myRepository;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    myProject = getProject();
+    myProjectRoot = myProject.getBaseDir();
+
+    createRepository(myProjectRoot);
+    myRepository = myProjectRoot;
+    setUpHgrc(myRepository);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    super.tearDown();
+  }
+
+  private static void setUpHgrc(VirtualFile repository) {
+    cd(".hg");
+    File pluginRoot = new File(PluginPathManager.getPluginHomePath("hg4idea"));
+    String pathToHgrc = "testData\\repo\\dot_hg";
+    File hgrcFile = new File(new File(pluginRoot, FileUtil.toSystemIndependentName(pathToHgrc)), "hgrc");
+    File hgrc = new File(new File(repository.getPath(), ".hg"), "hgrc");
+    try {
+      FileUtil.copy(hgrcFile, hgrc);
+    }
+    catch (IOException e) {
+      e.printStackTrace();
+      fail("Can not copy hgrc file.");
+    }
+    assertTrue(hgrc.exists());
+  }
+
+  protected void createRepository(VirtualFile root) {
+    initRepo(root.getPath());
+  }
+
+  private static void initRepo(String repoRoot) {
+    cd(repoRoot);
+    hg("init");
+    touch("file.txt");
+    hg("add file.txt");
+    hg("commit -m initial");
+  }
+
+}
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
index 9db9a21637b6..5804bde05dce 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
@@ -15,14 +15,13 @@
  */
 package hg4idea.test.diff;
 
-import com.intellij.dvcs.test.MockVirtualFile;
+import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.vcs.FilePath;
 import com.intellij.openapi.vcs.changes.Change;
-import hg4idea.test.HgLightTest;
-import org.junit.After;
-import org.junit.Test;
+import hg4idea.test.HgPlatformTest;
 import org.zmlx.hg4idea.HgFile;
 import org.zmlx.hg4idea.HgFileRevision;
+import org.zmlx.hg4idea.HgPlatformFacade;
 import org.zmlx.hg4idea.HgRevisionNumber;
 import org.zmlx.hg4idea.util.HgUtil;
 
@@ -30,31 +29,16 @@ import java.io.File;
 import java.util.List;
 
 import static hg4idea.test.HgExecutor.*;
-import static junit.framework.Assert.assertEquals;
 
 /**
  * @author Nadya Zabrodina
  */
+public class HgGetDiffForDirTest extends HgPlatformTest {
 
-public class HgGetDiffForDirTest extends HgLightTest {
-  private final String SHORT_TEMPLATE_REVISION = "{rev}:{node|short}";
-  MockVirtualFile myRepository;
+  private static final String SHORT_TEMPLATE_REVISION = "{rev}:{node|short}";
 
-
-  @Override
-  public void setUp() {
-    super.setUp();
-    myRepository = createRepository(myProjectRoot);
-  }
-
-  @After
-  public void tearDown() {
-    super.tearDown();
-  }
-
-  @Test
   public void testDiffForDir() {
-    cd(myProjectRoot);
+    cd(myRepository);
     touch("A.txt", "dsfdfdsf");
     hg("add A.txt");
     touch("B.txt");
@@ -67,7 +51,7 @@ public class HgGetDiffForDirTest extends HgLightTest {
     hg("add C.txt");
     hg("add D.txt");
     hg("commit -m createDir");
-    File dirFile = new File(myProjectRoot, "dir");
+    File dirFile = new File(myRepository.getPath(), "dir");
     String[] hash1 = hg("log -l 1 --template=" + SHORT_TEMPLATE_REVISION).split(":");
     HgRevisionNumber r1number = HgRevisionNumber.getInstance(hash1[0], hash1[1]);
     HgFileRevision rev1 =
@@ -80,7 +64,7 @@ public class HgGetDiffForDirTest extends HgLightTest {
     HgFileRevision rev2 =
       new HgFileRevision(myProject, new HgFile(myRepository, dirFile), r2number, "", null, "", "", null, null, null, null);
     FilePath dirPath = new com.intellij.openapi.vcs.FilePathImpl(dirFile, dirFile.isDirectory());
-    List<Change> changes = HgUtil.getDiff(myProject, myRepository, dirPath, rev1, rev2, myPlatformFacade);
+    List<Change> changes = HgUtil.getDiff(myProject, myRepository, dirPath, rev1, rev2, ServiceManager.getService(HgPlatformFacade.class));
     assertEquals(changes.size(), 2);
   }
 }

From ed840404b58b70222767ef1df762e5718bad1af2 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Mon, 25 Feb 2013 16:01:52 +0400
Subject: [PATCH 122/354] [dvcs tests] Fix log messages; add another cd()
 variant

Log messages weren't converted when the Executor class was converted
from Groovy to Java.
---
 .../com/intellij/dvcs/test/Executor.java            | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/platform/dvcs/testFramework/com/intellij/dvcs/test/Executor.java b/platform/dvcs/testFramework/com/intellij/dvcs/test/Executor.java
index bb81acd02ee0..400837369dd6 100644
--- a/platform/dvcs/testFramework/com/intellij/dvcs/test/Executor.java
+++ b/platform/dvcs/testFramework/com/intellij/dvcs/test/Executor.java
@@ -21,6 +21,7 @@ import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.CharsetToolkit;
+import com.intellij.openapi.vfs.VirtualFile;
 
 import java.io.File;
 import java.io.IOException;
@@ -53,6 +54,10 @@ public class Executor {
     }
   }
 
+  public static void cd(VirtualFile dir) {
+    cd(dir.getPath());
+  }
+
   public static String pwd() {
     return ourCurrentDir;
   }
@@ -157,15 +162,15 @@ public class Executor {
       for (String dir : path.split(File.pathSeparator)) {
         File file = new File(dir, name);
         if (file.canExecute()) {
-          log("Using $programName from PATH");
+          log("Using " + programName + " from PATH");
           return file.getPath();
         }
       }
     }
 
-    throw new IllegalStateException("$programName executable not found. " +
-                                    "Please define a valid environment variable ${pathEnvs.iterator().next()} " +
-                                    "pointing to the $programName executable.");
+    throw new IllegalStateException(programName + " executable not found. " +
+                                    "Please define a valid environment variable " + pathEnvs.iterator().next() +
+                                    " pointing to the " + programName + " executable.");
   }
 
   protected static void log(String msg) {

From 5e5eb96ff0b9a0d5fe0a7871405a897bb6c4b2e0 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Mon, 25 Feb 2013 16:04:58 +0400
Subject: [PATCH 123/354] [hg] HgGetDiffForDirTest: simplify

---
 .../testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
index 5804bde05dce..a35d92568be6 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
@@ -17,6 +17,7 @@ package hg4idea.test.diff;
 
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.vcs.FilePath;
+import com.intellij.openapi.vcs.FilePathImpl;
 import com.intellij.openapi.vcs.changes.Change;
 import hg4idea.test.HgPlatformTest;
 import org.zmlx.hg4idea.HgFile;
@@ -44,14 +45,13 @@ public class HgGetDiffForDirTest extends HgPlatformTest {
     touch("B.txt");
     hg("add B.txt");
     hg("commit -m 2files_added");
-    mkdir("dir");
+    File dirFile = new File(mkdir("dir"));
     cd("dir");
     touch("C.txt");
     touch("D.txt");
     hg("add C.txt");
     hg("add D.txt");
     hg("commit -m createDir");
-    File dirFile = new File(myRepository.getPath(), "dir");
     String[] hash1 = hg("log -l 1 --template=" + SHORT_TEMPLATE_REVISION).split(":");
     HgRevisionNumber r1number = HgRevisionNumber.getInstance(hash1[0], hash1[1]);
     HgFileRevision rev1 =
@@ -63,7 +63,7 @@ public class HgGetDiffForDirTest extends HgPlatformTest {
     HgRevisionNumber r2number = HgRevisionNumber.getInstance(hash2[0], hash2[1]);
     HgFileRevision rev2 =
       new HgFileRevision(myProject, new HgFile(myRepository, dirFile), r2number, "", null, "", "", null, null, null, null);
-    FilePath dirPath = new com.intellij.openapi.vcs.FilePathImpl(dirFile, dirFile.isDirectory());
+    FilePath dirPath = new FilePathImpl(dirFile, true);
     List<Change> changes = HgUtil.getDiff(myProject, myRepository, dirPath, rev1, rev2, ServiceManager.getService(HgPlatformFacade.class));
     assertEquals(changes.size(), 2);
   }

From 8d651e0f86f1b0ee765e6291dc954a807f9198e3 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Mon, 25 Feb 2013 16:43:25 +0400
Subject: [PATCH 124/354] [hg] Remove HgPlatformFacade & other mocking stuff

After some discussion it was decided to use HgPlatformTests which
work on the production platform.
---
 .../org/zmlx/hg4idea/HgPlatformFacade.java    |  32 --
 .../zmlx/hg4idea/HgPlatformFacadeImpl.java    |  34 --
 .../hg4idea/src/org/zmlx/hg4idea/HgVcs.java   |   4 +-
 .../zmlx/hg4idea/command/HgStatusCommand.java |  17 +-
 .../hg4idea/execution/HgCommandExecutor.java  |  18 +-
 .../zmlx/hg4idea/execution/SocketServer.java  |   8 +-
 .../provider/HgDiffFromHistoryHandler.java    |   5 +-
 .../src/org/zmlx/hg4idea/util/HgUtil.java     |   4 +-
 .../testSrc/hg4idea/test/HgMockVcs.java       |  45 ---
 .../hg4idea/test/HgMockVcsManager.java        | 321 ------------------
 .../hg4idea/test/HgTestPlatformFacade.java    |  61 ----
 .../test/diff/HgGetDiffForDirTest.java        |   4 +-
 12 files changed, 20 insertions(+), 533 deletions(-)
 delete mode 100644 plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacade.java
 delete mode 100644 plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacadeImpl.java
 delete mode 100644 plugins/hg4idea/testSrc/hg4idea/test/HgMockVcs.java
 delete mode 100644 plugins/hg4idea/testSrc/hg4idea/test/HgMockVcsManager.java
 delete mode 100644 plugins/hg4idea/testSrc/hg4idea/test/HgTestPlatformFacade.java

diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacade.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacade.java
deleted file mode 100644
index 3eebfbd53098..000000000000
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacade.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2000-2013 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 org.zmlx.hg4idea;
-
-/**
- * @author Nadya Zabrodina
- */
-
-import com.intellij.dvcs.DvcsPlatformFacade;
-import com.intellij.openapi.project.Project;
-import org.jetbrains.annotations.NotNull;
-
-public interface HgPlatformFacade extends DvcsPlatformFacade {
-
-  @Override
-  @NotNull
-  HgVcs getVcs(@NotNull Project project);
-
-}
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacadeImpl.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacadeImpl.java
deleted file mode 100644
index 4a13cb4b4d45..000000000000
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgPlatformFacadeImpl.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2000-2013 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 org.zmlx.hg4idea;
-
-import com.intellij.dvcs.DvcsPlatformFacadeImpl;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vcs.ProjectLevelVcsManager;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * @author Nadya Zabrodina
- */
-public class HgPlatformFacadeImpl extends DvcsPlatformFacadeImpl implements HgPlatformFacade {
-
-  @NotNull
-  @Override
-  public HgVcs getVcs(@NotNull Project project) {
-    final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
-    return (HgVcs)vcsManager.findVcsByName(HgVcs.VCS_NAME);
-  }
-}
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVcs.java b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVcs.java
index 4c986b8f544a..a33f235aaf4b 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/HgVcs.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/HgVcs.java
@@ -84,7 +84,6 @@ public class HgVcs extends AbstractVcs<CommittedChangeList> {
   private final HgAnnotationProvider annotationProvider;
   private final HgUpdateEnvironment updateEnvironment;
   private final HgCachingCommitedChangesProvider commitedChangesProvider;
-  protected final @NotNull HgPlatformFacade myPlatformFacade;
   private MessageBusConnection messageBusConnection;
   @NotNull private final HgGlobalSettings globalSettings;
   @NotNull private final HgProjectSettings projectSettings;
@@ -106,7 +105,7 @@ public class HgVcs extends AbstractVcs<CommittedChangeList> {
   public HgVcs(Project project,
                @NotNull HgGlobalSettings globalSettings,
                @NotNull HgProjectSettings projectSettings,
-               ProjectLevelVcsManager vcsManager, @NotNull HgPlatformFacade platformFacade) {
+               ProjectLevelVcsManager vcsManager) {
     super(project, VCS_NAME);
     this.globalSettings = globalSettings;
     this.projectSettings = projectSettings;
@@ -121,7 +120,6 @@ public class HgVcs extends AbstractVcs<CommittedChangeList> {
     commitedChangesProvider = new HgCachingCommitedChangesProvider(project, this);
     myMergeProvider = new HgMergeProvider(myProject);
     myCommitAndPushExecutor = new HgCommitAndPushExecutor(checkinEnvironment);
-    myPlatformFacade = platformFacade;
   }
 
   public String getDisplayName() {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
index 6953b74f034b..46957961c0cf 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/command/HgStatusCommand.java
@@ -12,7 +12,6 @@
 // limitations under the License.
 package org.zmlx.hg4idea.command;
 
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.text.StringUtil;
@@ -23,7 +22,10 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.vcsUtil.VcsFileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.zmlx.hg4idea.*;
+import org.zmlx.hg4idea.HgChange;
+import org.zmlx.hg4idea.HgFile;
+import org.zmlx.hg4idea.HgFileStatusEnum;
+import org.zmlx.hg4idea.HgRevisionNumber;
 import org.zmlx.hg4idea.execution.HgCommandExecutor;
 import org.zmlx.hg4idea.execution.HgCommandResult;
 
@@ -49,7 +51,6 @@ public class HgStatusCommand {
 
   @Nullable private HgRevisionNumber baseRevision;
   @Nullable private HgRevisionNumber targetRevision;
-  private HgPlatformFacade myPlatformFacade;
 
 
   public static class Builder {
@@ -87,17 +88,13 @@ public class HgStatusCommand {
     }
 
     public HgStatusCommand build(Project project) {
-      return new HgStatusCommand(project, ServiceManager.getService(project, HgPlatformFacade.class), this);
+      return new HgStatusCommand(project, this);
     }
 
-    public HgStatusCommand build(Project project, HgPlatformFacade facade) {
-      return new HgStatusCommand(project, facade, this);
-    }
   }
 
-  private HgStatusCommand(Project project, HgPlatformFacade facade, Builder builder) {
+  private HgStatusCommand(Project project, Builder builder) {
     this.project = project;
-    myPlatformFacade = facade;
     includeAdded = builder.includeAdded;
     includeModified = builder.includeModified;
     includeRemoved = builder.includeRemoved;
@@ -124,7 +121,7 @@ public class HgStatusCommand {
       return Collections.emptySet();
     }
 
-    HgCommandExecutor executor = new HgCommandExecutor(project, null, myPlatformFacade);
+    HgCommandExecutor executor = new HgCommandExecutor(project, null);
     executor.setSilent(true);
 
     List<String> options = new LinkedList<String>();
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/execution/HgCommandExecutor.java b/plugins/hg4idea/src/org/zmlx/hg4idea/execution/HgCommandExecutor.java
index 4a129488087b..0b039bd048c2 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/execution/HgCommandExecutor.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/execution/HgCommandExecutor.java
@@ -13,7 +13,6 @@
 package org.zmlx.hg4idea.execution;
 
 import com.intellij.execution.ui.ConsoleViewContentType;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
@@ -23,7 +22,6 @@ import com.intellij.vcsUtil.VcsImplUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.zmlx.hg4idea.HgGlobalSettings;
-import org.zmlx.hg4idea.HgPlatformFacade;
 import org.zmlx.hg4idea.HgVcs;
 import org.zmlx.hg4idea.HgVcsMessages;
 import org.zmlx.hg4idea.action.HgCommandResultNotifier;
@@ -66,20 +64,14 @@ public final class HgCommandExecutor {
   private boolean myIsSilent = false;
   private boolean myShowOutput = false;
   private List<String> myOptions = DEFAULT_OPTIONS;
-  private HgPlatformFacade myPlatformFacade;
 
   public HgCommandExecutor(Project project) {
-    this(project, null, ServiceManager.getService(project, HgPlatformFacade.class));
+    this(project, null);
   }
 
   public HgCommandExecutor(Project project, @Nullable String destination) {
-    this(project, destination, ServiceManager.getService(project, HgPlatformFacade.class));
-  }
-
-  public HgCommandExecutor(Project project, @Nullable String destination, HgPlatformFacade platformFacade) {
     myProject = project;
-    myPlatformFacade = platformFacade;
-    myVcs = platformFacade.getVcs(project);
+    myVcs = HgVcs.getInstance(project);
     myDestination = destination;
   }
 
@@ -155,9 +147,9 @@ public final class HgCommandExecutor {
     WarningReceiver warningReceiver = new WarningReceiver();
     PassReceiver passReceiver = new PassReceiver(myProject, forceAuthorization);
 
-    SocketServer promptServer = new SocketServer(new PromptReceiver(handler), myPlatformFacade);
-    SocketServer warningServer = new SocketServer(warningReceiver, myPlatformFacade);
-    SocketServer passServer = new SocketServer(passReceiver, myPlatformFacade);
+    SocketServer promptServer = new SocketServer(new PromptReceiver(handler));
+    SocketServer warningServer = new SocketServer(warningReceiver);
+    SocketServer passServer = new SocketServer(passReceiver);
 
     try {
       int promptPort = promptServer.start();
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/execution/SocketServer.java b/plugins/hg4idea/src/org/zmlx/hg4idea/execution/SocketServer.java
index fc8ee0bc5124..453fddfada90 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/execution/SocketServer.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/execution/SocketServer.java
@@ -12,8 +12,8 @@
 // limitations under the License.
 package org.zmlx.hg4idea.execution;
 
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
-import org.zmlx.hg4idea.HgPlatformFacade;
 
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
@@ -29,18 +29,16 @@ import java.net.SocketException;
 public class SocketServer {
   protected ServerSocket myServerSocket;
   private final Protocol myProtocol;
-  private HgPlatformFacade myPlatformFacade;
 
-  public SocketServer(Protocol protocol,HgPlatformFacade facade) {
+  public SocketServer(Protocol protocol) {
     myProtocol = protocol;
-    myPlatformFacade = facade;
   }
 
   public int start() throws IOException {
     myServerSocket = new ServerSocket(0);
     int port = myServerSocket.getLocalPort();
 
-    myPlatformFacade.executeOnPooledThread(new Runnable() {
+    ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
       @Override
       public void run() {
         try {
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgDiffFromHistoryHandler.java b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgDiffFromHistoryHandler.java
index b9cf96538e65..7f4c40f9ac5b 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgDiffFromHistoryHandler.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/provider/HgDiffFromHistoryHandler.java
@@ -16,7 +16,6 @@
 package org.zmlx.hg4idea.provider;
 
 import com.intellij.openapi.actionSystem.AnActionEvent;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
@@ -36,7 +35,6 @@ import com.intellij.vcsUtil.VcsUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.zmlx.hg4idea.HgFileRevision;
-import org.zmlx.hg4idea.HgPlatformFacade;
 import org.zmlx.hg4idea.util.HgUtil;
 
 import java.util.List;
@@ -118,8 +116,7 @@ public class HgDiffFromHistoryHandler implements DiffFromHistoryHandler {
       @Override
       public void run(@NotNull ProgressIndicator indicator) {
         if (myProject != null) {
-          myChanges = HgUtil.getDiff(HgDiffFromHistoryHandler.this.myProject, root, path, rev1, rev2, ServiceManager
-            .getService(myProject, HgPlatformFacade.class));
+          myChanges = HgUtil.getDiff(HgDiffFromHistoryHandler.this.myProject, root, path, rev1, rev2);
         }
       }
 
diff --git a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
index d750f172b3a1..9747fb45904b 100644
--- a/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
+++ b/plugins/hg4idea/src/org/zmlx/hg4idea/util/HgUtil.java
@@ -399,8 +399,8 @@ public abstract class HgUtil {
                                      @NotNull final VirtualFile root,
                                      @NotNull final FilePath path,
                                      @Nullable final HgFileRevision rev1,
-                                     @Nullable final HgFileRevision rev2, HgPlatformFacade facade) {
-    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).includeCopySource(false).build(project, facade);
+                                     @Nullable final HgFileRevision rev2) {
+    HgStatusCommand statusCommand = new HgStatusCommand.Builder(true).includeCopySource(false).build(project);
     HgRevisionNumber revNumber1 = null;
     if (rev1 != null) {
       revNumber1 = rev1.getRevisionNumber();
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcs.java b/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcs.java
deleted file mode 100644
index cac1ddda0967..000000000000
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcs.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2000-2013 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 hg4idea.test;
-
-import com.intellij.openapi.options.Configurable;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vcs.ProjectLevelVcsManager;
-import org.zmlx.hg4idea.HgGlobalSettings;
-import org.zmlx.hg4idea.HgProjectSettings;
-import org.zmlx.hg4idea.HgVcs;
-
-/**
- * @author Nadya Zabrodina
- */
-class HgMockVcs extends HgVcs {
-
-  public HgMockVcs(Project project, HgGlobalSettings globalSettings,
-                   HgProjectSettings projectSettings,
-                   ProjectLevelVcsManager vcsManager) {
-    super(project, globalSettings, projectSettings, vcsManager, new HgTestPlatformFacade());
-  }
-
-  @Override
-  public String getDisplayName() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public Configurable getConfigurable() {
-    throw new UnsupportedOperationException();
-  }
-}
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcsManager.java b/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcsManager.java
deleted file mode 100644
index c1a80b9b86af..000000000000
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgMockVcsManager.java
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * Copyright 2000-2013 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 hg4idea.test;
-
-import com.intellij.dvcs.test.MockVirtualFile;
-import com.intellij.openapi.editor.markup.TextAttributes;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vcs.*;
-import com.intellij.openapi.vcs.changes.VcsAnnotationLocalChangesListener;
-import com.intellij.openapi.vcs.history.VcsHistoryCache;
-import com.intellij.openapi.vcs.impl.ContentRevisionCache;
-import com.intellij.openapi.vcs.impl.VcsDescriptor;
-import com.intellij.openapi.vcs.impl.VcsEnvironmentsProxyCreator;
-import com.intellij.openapi.vcs.update.UpdatedFiles;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Processor;
-import org.jetbrains.annotations.NotNull;
-import org.zmlx.hg4idea.HgPlatformFacade;
-import org.zmlx.hg4idea.HgVcs;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-/**
- * @author Nadya Zabrodina
- */
-public class HgMockVcsManager extends ProjectLevelVcsManager {
-
-  Project myProject;
-  HgPlatformFacade myPlatformFacade;
-  Collection<String> myRoots = new ArrayList<String>();
-  boolean myProjectRootMapping = false;
-
-  HgMockVcsManager(Project project, HgPlatformFacade facade) {
-    myProject = project;
-    myPlatformFacade = facade;
-  }
-
-  public void addRoots(String... roots) {
-    myRoots.addAll(Arrays.asList(roots));
-  }
-
-  public void setProjectRootMapping() {
-    myProjectRootMapping = true;
-  }
-
-  @Override
-  public VirtualFile[] getRootsUnderVcs(AbstractVcs vcs) {
-
-    List<VirtualFile> roots = new ArrayList<VirtualFile>();
-    for (String root : myRoots) {
-      roots.add(new MockVirtualFile(root));
-    }
-    roots.addAll(Arrays.asList(myPlatformFacade.getProjectRootManager(myProject).getContentRoots()));
-    return roots.toArray(new VirtualFile[0]);
-  }
-
-  @Override
-  public List<VcsDirectoryMapping> getDirectoryMappings() {
-    List<VcsDirectoryMapping> roots = new ArrayList<VcsDirectoryMapping>();
-    for (String root : myRoots) {
-      roots.add(new VcsDirectoryMapping(root, HgVcs.VCS_NAME));
-    }
-
-    if (myProjectRootMapping) {
-      roots.add(new VcsDirectoryMapping("", HgVcs.VCS_NAME));
-    }
-    return roots;
-  }
-
-  @Override
-  public List<VcsDirectoryMapping> getDirectoryMappings(AbstractVcs vcs) {
-    return getDirectoryMappings();
-  }
-
-  @Override
-  public void setDirectoryMappings(List<VcsDirectoryMapping> items) {
-    for (VcsDirectoryMapping item : items) {
-      myRoots.add(item.getDirectory());
-    }
-  }
-
-  @Override
-  public void iterateVfUnderVcsRoot(VirtualFile file, Processor<VirtualFile> processor) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsAnnotationLocalChangesListener getAnnotationLocalChangesListener() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsDescriptor[] getAllVcss() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public AbstractVcs findVcsByName(String name) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsDescriptor getDescriptor(String name) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean checkAllFilesAreUnder(AbstractVcs abstractVcs, VirtualFile[] files) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public AbstractVcs getVcsFor(@NotNull VirtualFile file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public AbstractVcs getVcsFor(FilePath file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VirtualFile getVcsRootFor(VirtualFile file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VirtualFile getVcsRootFor(FilePath file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsRoot getVcsRootObjectFor(VirtualFile file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsRoot getVcsRootObjectFor(FilePath file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean checkVcsIsActive(AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean checkVcsIsActive(String vcsName) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public AbstractVcs[] getAllActiveVcss() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean hasActiveVcss() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean hasAnyMappings() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void addMessageToConsoleWindow(String message, TextAttributes attributes) {
-    throw new UnsupportedOperationException();
-  }
-
-  @NotNull
-  @Override
-  public VcsShowSettingOption getStandardOption(@NotNull VcsConfiguration.StandardOption option, @NotNull AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @NotNull
-  @Override
-  public VcsShowConfirmationOption getStandardConfirmation(@NotNull VcsConfiguration.StandardConfirmation option, AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @NotNull
-  @Override
-  public VcsShowSettingOption getOrCreateCustomOption(@NotNull String vcsActionName, @NotNull AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void showProjectOperationInfo(UpdatedFiles updatedFiles, String displayActionName) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void addVcsListener(VcsListener listener) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void removeVcsListener(VcsListener listener) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void startBackgroundVcsOperation() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void stopBackgroundVcsOperation() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean isBackgroundVcsOperationRunning() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public List<VirtualFile> getRootsUnderVcsWithoutFiltering(AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public List<VirtualFile> getDetailedVcsMappings(AbstractVcs vcs) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VirtualFile[] getAllVersionedRoots() {
-    throw new UnsupportedOperationException();
-  }
-
-  @NotNull
-  @Override
-  public VcsRoot[] getAllVcsRoots() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void updateActiveVcss() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsDirectoryMapping getDirectoryMappingFor(FilePath path) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void setDirectoryMapping(String path, String activeVcsName) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void iterateVcsRoot(VirtualFile root, Processor<FilePath> iterator) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void iterateVcsRoot(VirtualFile root, Processor<FilePath> iterator, com.intellij.openapi.vcs.VirtualFileFilter directoryFilter) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public AbstractVcs findVersioningVcs(VirtualFile file) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public CheckoutProvider.Listener getCompositeCheckoutListener() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsEventsListenerManager getVcsEventsListenerManager() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  protected VcsEnvironmentsProxyCreator getProxyCreator() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public VcsHistoryCache getVcsHistoryCache() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public ContentRevisionCache getContentRevisionCache() {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean isFileInContent(VirtualFile vf) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public boolean dvcsUsedInProject() {
-    throw new UnsupportedOperationException();
-  }
-}
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgTestPlatformFacade.java b/plugins/hg4idea/testSrc/hg4idea/test/HgTestPlatformFacade.java
deleted file mode 100644
index 7c21b0f638cc..000000000000
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgTestPlatformFacade.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2000-2013 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 hg4idea.test;
-
-import com.intellij.dvcs.test.DvcsTestPlatformFacade;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.DialogWrapper;
-import com.intellij.openapi.vcs.ProjectLevelVcsManager;
-import org.jetbrains.annotations.NotNull;
-import org.zmlx.hg4idea.HgGlobalSettings;
-import org.zmlx.hg4idea.HgPlatformFacade;
-import org.zmlx.hg4idea.HgProjectSettings;
-import org.zmlx.hg4idea.HgVcs;
-
-/**
- * @author Nadya Zabrodina
- */
-public class HgTestPlatformFacade extends DvcsTestPlatformFacade implements HgPlatformFacade {
-  private HgMockVcs myVcs;
-  private HgMockVcsManager myVcsManager;
-
-  @NotNull
-  @Override
-  public HgVcs getVcs(@NotNull Project project) {
-    if (myVcs == null) {
-      HgGlobalSettings globalSettings = new HgGlobalSettings();
-      myVcs = new HgMockVcs(project, globalSettings, new HgProjectSettings(globalSettings), new HgMockVcsManager(project, this));
-    }
-    return myVcs;
-  }
-
-
-  @NotNull
-  @Override
-  public ProjectLevelVcsManager getVcsManager(@NotNull Project project) {
-    if (myVcsManager == null) {
-      myVcsManager = new HgMockVcsManager(project, this);
-    }
-    return myVcsManager;
-  }
-
-
-  @Override
-  public void showDialog(@NotNull DialogWrapper dialog) {
-    throw new UnsupportedOperationException();
-  }
-}
-
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
index a35d92568be6..19b3b8871477 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/diff/HgGetDiffForDirTest.java
@@ -15,14 +15,12 @@
  */
 package hg4idea.test.diff;
 
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.vcs.FilePath;
 import com.intellij.openapi.vcs.FilePathImpl;
 import com.intellij.openapi.vcs.changes.Change;
 import hg4idea.test.HgPlatformTest;
 import org.zmlx.hg4idea.HgFile;
 import org.zmlx.hg4idea.HgFileRevision;
-import org.zmlx.hg4idea.HgPlatformFacade;
 import org.zmlx.hg4idea.HgRevisionNumber;
 import org.zmlx.hg4idea.util.HgUtil;
 
@@ -64,7 +62,7 @@ public class HgGetDiffForDirTest extends HgPlatformTest {
     HgFileRevision rev2 =
       new HgFileRevision(myProject, new HgFile(myRepository, dirFile), r2number, "", null, "", "", null, null, null, null);
     FilePath dirPath = new FilePathImpl(dirFile, true);
-    List<Change> changes = HgUtil.getDiff(myProject, myRepository, dirPath, rev1, rev2, ServiceManager.getService(HgPlatformFacade.class));
+    List<Change> changes = HgUtil.getDiff(myProject, myRepository, dirPath, rev1, rev2);
     assertEquals(changes.size(), 2);
   }
 }

From 6e5cb7c339fc015e468265e2c15dd09ba78ca821 Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Mon, 25 Feb 2013 17:11:57 +0400
Subject: [PATCH 125/354] IDEA-83960 Maven import scope in dependency
 management section not recognized

---
 .../dom/MavenDomProjectProcessorUtils.java    | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenDomProjectProcessorUtils.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenDomProjectProcessorUtils.java
index 04fc290b0c7b..a3b3cd35e410 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenDomProjectProcessorUtils.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenDomProjectProcessorUtils.java
@@ -18,12 +18,17 @@ package org.jetbrains.idea.maven.dom;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.xml.XmlFile;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.Function;
 import com.intellij.util.Processor;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.hash.HashSet;
 import com.intellij.util.xml.DomUtil;
+import com.intellij.util.xml.GenericDomValue;
+import com.intellij.util.xml.impl.GenericDomValueReference;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.maven.dom.model.*;
@@ -316,12 +321,33 @@ public class MavenDomProjectProcessorUtils {
                 groupId.equals(domDependency.getGroupId().getStringValue())) {
               return domDependency;
             }
+
+            if ("import".equals(domDependency.getScope().getRawText())) {
+              GenericDomValue<String> version = domDependency.getVersion();
+              if (version.getXmlElement() != null) {
+                GenericDomValueReference reference = new GenericDomValueReference(version);
+                PsiElement resolve = reference.resolve();
+
+                if (resolve instanceof XmlFile) {
+                  MavenDomProjectModel dependModel = MavenDomUtil.getMavenDomModel((PsiFile)resolve, MavenDomProjectModel.class);
+                  if (dependModel != null) {
+                    for (MavenDomDependency dep : dependModel.getDependencyManagement().getDependencies().getDependencies()) {
+                      if (artifactId.equals(dep.getArtifactId().getStringValue()) &&
+                          groupId.equals(dep.getGroupId().getStringValue())) {
+                        return domDependency;
+                      }
+                    }
+                  }
+                }
+              }
+            }
           }
         }
 
         return null;
       }
     };
+
     processDependenciesInDependencyManagement(model, processor, project);
 
     return processor.myResult;

From a684c033a1f6ed8430320cb445fcb64cf36a69bc Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 13:40:41 +0100
Subject: [PATCH 126/354] lambda: replace raw inference from lambda with Object
 when it doesn't matter (IDEA-101788)

---
 .../source/resolve/PsiResolveHelperImpl.java  | 49 +++++++++++++++++--
 .../highlighting/AcceptRawSubstForLambda.java | 30 ++++++++++++
 .../daemon/lambda/LambdaHighlightingTest.java |  4 ++
 3 files changed, 79 insertions(+), 4 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AcceptRawSubstForLambda.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
index 5af0d2dae5b3..5c5aa513970b 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
@@ -205,6 +205,7 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
       sortLambdaExpressionsLast(paramTypes, argTypes);
       boolean rawType = false;
       boolean nullPassed = false;
+      boolean lambdaRaw = false;
       for (int j = 0; j < argTypes.length; j++) {
         PsiType argumentType = argTypes[j];
         if (argumentType == null) continue;
@@ -228,6 +229,12 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
             if (currentSubstitution == FAILED_INFERENCE || (currentSubstitution == null && lowerBound == PsiType.NULL)) return RAW_INFERENCE;
           }
           if (nullPassed && currentSubstitution == null) return RAW_INFERENCE;
+          if (currentSubstitution != null && currentSubstitution.first == null) {
+            lambdaRaw = true;
+          }
+          if (currentSubstitution == null && lambdaRaw) {
+            return new Pair<PsiType, ConstraintType>(PsiType.getJavaLangObject(typeParameter.getManager(), typeParameter.getResolveScope()), ConstraintType.EQUALS);
+          }
         } else if (argumentType instanceof PsiMethodReferenceType) {
           final PsiMethodReferenceExpression referenceExpression = ((PsiMethodReferenceType)argumentType).getExpression();
           currentSubstitution = inferConstraintFromFunctionalInterfaceMethod(typeParameter, referenceExpression, partialSubstitutor.substitute(parameterType), partialSubstitutor, policy);
@@ -998,7 +1005,7 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
     return null;
   }
 
-  private static Pair<PsiType, ConstraintType> inferMethodTypeParameterFromParent(PsiElement parent,
+  private static Pair<PsiType, ConstraintType> inferMethodTypeParameterFromParent(final PsiElement parent,
                                                                                   PsiExpression methodCall,
                                                                                   final PsiTypeParameter typeParameter,
                                                                                   PsiSubstitutor substitutor,
@@ -1065,16 +1072,24 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
         }
       }
     } else if (parent instanceof PsiLambdaExpression) {
-      expectedType = LambdaUtil.getFunctionalInterfaceReturnType(((PsiLambdaExpression)parent).getFunctionalInterfaceType());
+      expectedType = ourGraphGuard.doPreventingRecursion(methodCall, true, new Computable<PsiType>() {
+        @Override
+        public PsiType compute() {
+          return LambdaUtil.getFunctionalInterfaceReturnType(((PsiLambdaExpression)parent).getFunctionalInterfaceType()); 
+        }
+      });
       if (expectedType == null) {
-        return getFailedInferenceConstraint(typeParameter);
+        return null;
       }
     } else if (parent instanceof PsiTypeCastExpression) {
       expectedType = ((PsiTypeCastExpression)parent).getType();
     } else if (parent instanceof PsiConditionalExpression) {
       if (PsiUtil.isLanguageLevel8OrHigher(parent)) {
         try {
-          return inferMethodTypeParameterFromParent(PsiUtil.skipParenthesizedExprUp(parent.getParent()), (PsiExpression)parent, typeParameter, substitutor, policy);
+          final Pair<PsiType, ConstraintType> pair = inferFromConditionalExpression(parent, methodCall, typeParameter, substitutor, policy);
+          if (pair != null) {
+            return pair;
+          }
         }
         finally {
           GraphInferencePolicy.forget(parent);
@@ -1175,6 +1190,32 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
     return result;
   }
 
+  private static Pair<PsiType, ConstraintType> inferFromConditionalExpression(PsiElement parent,
+                                                                              PsiExpression methodCall,
+                                                                              PsiTypeParameter typeParameter,
+                                                                              PsiSubstitutor substitutor,
+                                                                              ParameterTypeInferencePolicy policy) {
+    Pair<PsiType, ConstraintType> pair =
+      inferMethodTypeParameterFromParent(PsiUtil.skipParenthesizedExprUp(parent.getParent()), (PsiExpression)parent, typeParameter, substitutor, policy);
+    if (pair == null) {
+      final PsiExpression thenExpression = ((PsiConditionalExpression)parent).getThenExpression();
+      final PsiExpression elseExpression = ((PsiConditionalExpression)parent).getElseExpression();
+      final PsiType[] paramTypes = {((PsiMethod)typeParameter.getOwner()).getReturnType()};
+      if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(elseExpression)) && thenExpression != null) {
+        final PsiType thenType = thenExpression.getType();
+        if (thenType != null) {
+          pair = inferTypeForMethodTypeParameterInner(typeParameter, paramTypes, new PsiType[] {thenType}, substitutor, null, policy);
+        }
+      } else if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(thenExpression)) && elseExpression != null) {
+        final PsiType elseType = elseExpression.getType();
+        if (elseType != null) {
+          pair = inferTypeForMethodTypeParameterInner(typeParameter, paramTypes, new PsiType[] {elseType}, substitutor, null, policy);
+        }
+      }
+    }
+    return pair;
+  }
+
   private static final ProcessCandidateParameterTypeInferencePolicy GRAPH_INFERENCE_POLICY = new GraphInferencePolicy();
 
   private static Pair<PsiType, ConstraintType> graphInferenceFromCallContext(@NotNull final PsiExpression methodCall,
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AcceptRawSubstForLambda.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AcceptRawSubstForLambda.java
new file mode 100644
index 000000000000..9f7573f82c4a
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AcceptRawSubstForLambda.java
@@ -0,0 +1,30 @@
+public class CyclicReferenceTest {
+    void test(Match<String, Integer> match) {
+        Match<String, Integer> matcher = match.or(s -> Optional.empty(), i -> 2);
+        Match<String, Integer> matcher1 = match.or(s -> s.startsWith("_") ? Optional.of(1) : Optional.empty(), i -> 2);
+    }
+}
+
+class Match<T, V> {
+    public <W> Match<T, V> or(Extractor<T, W> e, Function<W, V> c) {
+        return this;
+    }
+}
+
+interface Extractor<T, W> {
+    Optional<W> unapply(T t);
+}
+
+interface Function<W, V> {
+    public V apply(W t);
+}
+
+class Optional<W> {
+    public static <T> Optional<T> empty() {
+        return null;
+    }
+  
+    public static <T> Optional<T> of(T value) {
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index fb83818521de..53fa466743e8 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -216,6 +216,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testAcceptRawSubstForLambda() throws Exception {
+    doTest();
+  }
+
   public void testCheckFunctionalInterfaceAccess() throws Exception {
     doTest();
   }

From c45789ea949a3e5ccdcda73b31ff206a6dfd6c73 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 14:09:54 +0100
Subject: [PATCH 127/354] possible NPEs

---
 .../nullable/NullableStuffInspection.java           | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
index 4343faee75a7..b59d821bbecf 100644
--- a/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspection.java
@@ -303,7 +303,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
         holder.registerProblem(method.getNameIdentifier(),
                                InspectionsBundle.message("inspection.nullable.problems.method.overrides.NotNull"),
                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                               fix);
+                               wrapFix(fix));
       }
       if (REPORT_NOTNULL_PARAMETER_OVERRIDES_NULLABLE || REPORT_NOT_ANNOTATED_METHOD_OVERRIDES_NOTNULL) {
         PsiParameter[] superParameters = superMethod.getParameterList().getParameters();
@@ -331,7 +331,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
               holder.registerProblem(parameter.getNameIdentifier(),
                                      InspectionsBundle.message("inspection.nullable.problems.parameter.overrides.NotNull"),
                                      ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                     fix);
+                                     wrapFix(fix));
             }
           }
         }
@@ -376,7 +376,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
 
             holder.registerProblem(annotation, InspectionsBundle.message("nullable.stuff.problems.overridden.methods.are.not.annotated"),
                                    ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                   fix);
+                                   wrapFix(fix));
             methodQuickFixSuggested = true;
           }
           if (hasAnnotatedParameter) {
@@ -390,7 +390,7 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
                 holder.registerProblem(annotation,
                                        InspectionsBundle.message("nullable.stuff.problems.overridden.method.parameters.are.not.annotated"),
                                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
-                                       !applicable ? createChangeDefaultNotNullFix(nullableManager, parameters[i]) : new AnnotateOverriddenMethodParameterFix(defaultNotNull, nullableManager.getDefaultNullable()));
+                                       wrapFix(!applicable ? createChangeDefaultNotNullFix(nullableManager, parameters[i]) : new AnnotateOverriddenMethodParameterFix(defaultNotNull, nullableManager.getDefaultNullable())));
                 parameterQuickFixSuggested[i] = true;
               }
             }
@@ -400,6 +400,11 @@ public class NullableStuffInspection extends BaseLocalInspectionTool {
     }
   }
 
+  private static LocalQuickFix[] wrapFix(LocalQuickFix fix) {
+    if (fix == null) return LocalQuickFix.EMPTY_ARRAY;
+    return new LocalQuickFix[]{fix};
+  }
+
   private static LocalQuickFix createChangeDefaultNotNullFix(NullableNotNullManager nullableManager, PsiModifierListOwner modifierListOwner) {
     final PsiAnnotation annotation = AnnotationUtil.findAnnotation(modifierListOwner, nullableManager.getNotNulls());
     if (annotation != null) {

From 3a9ce687cb198ccd3d58f35fe084d52bbd2273ca Mon Sep 17 00:00:00 2001
From: Ekaterina Tuzova <Ekaterina.Tuzova@jetbrains.com>
Date: Mon, 25 Feb 2013 17:14:13 +0400
Subject: [PATCH 128/354] set Editor for Injected languages highlighter

fixed PY-7862 Doctest: closing quote is not inserted automatically inside doctest
---
 .../src/com/intellij/injected/editor/EditorWindow.java          | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/platform/lang-impl/src/com/intellij/injected/editor/EditorWindow.java b/platform/lang-impl/src/com/intellij/injected/editor/EditorWindow.java
index 15d08574aafc..d6da349d512a 100644
--- a/platform/lang-impl/src/com/intellij/injected/editor/EditorWindow.java
+++ b/platform/lang-impl/src/com/intellij/injected/editor/EditorWindow.java
@@ -33,6 +33,7 @@ import com.intellij.openapi.editor.event.EditorMouseMotionListener;
 import com.intellij.openapi.editor.ex.*;
 import com.intellij.openapi.editor.ex.util.EditorUtil;
 import com.intellij.openapi.editor.highlighter.EditorHighlighter;
+import com.intellij.openapi.editor.highlighter.LightHighlighterClient;
 import com.intellij.openapi.editor.impl.EditorImpl;
 import com.intellij.openapi.editor.impl.TextDrawingCallback;
 import com.intellij.openapi.editor.impl.softwrap.SoftWrapAppliancePlaces;
@@ -292,6 +293,7 @@ public class EditorWindow extends UserDataHolderBase implements EditorEx {
     EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
     EditorHighlighter highlighter = HighlighterFactory.createHighlighter(myInjectedFile.getVirtualFile(), scheme, getProject());
     highlighter.setText(getDocument().getText());
+    highlighter.setEditor(new LightHighlighterClient(getDocument(), getProject()));
     return highlighter;
   }
 

From 28d0043fac756c40415db8583b3bb58a7f5ad73c Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Mon, 25 Feb 2013 17:16:21 +0400
Subject: [PATCH 129/354] IDEA-101809 Missing "Abbreviate Qualified Package
 Names" option in the Favorites window

---
 .../FavoritesTreeViewPanel.java               | 11 +++--
 .../FavoritesViewSettings.java                | 10 +++-
 ...FavoritesAbbreviatePackageNamesAction.java | 47 +++++++++++++++++++
 ...ritesCompactEmptyMiddlePackagesAction.java | 29 +++++++++---
 4 files changed, 85 insertions(+), 12 deletions(-)
 create mode 100644 platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesAbbreviatePackageNamesAction.java

diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
index 84b29b056686..6c5cf7f9f8d0 100644
--- a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
+++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
@@ -588,19 +588,20 @@ public class FavoritesTreeViewPanel extends JPanel implements DataProvider, Dock
     window.setTitleActions(collapseAction);
 
     final DefaultActionGroup group = new DefaultActionGroup();
-    if (!PlatformUtils.isAppCode()) {
-      group.add(new FavoritesShowMembersAction(myProject, myBuilder));
-    }
-
     final ProjectViewDirectoryHelper helper = ProjectViewDirectoryHelper.getInstance(myProject);
 
     if (helper.supportsFlattenPackages()) {
       group.add(new FavoritesFlattenPackagesAction(myProject, myBuilder));
     }
-
     if (helper.supportsHideEmptyMiddlePackages()) {
       group.add(new FavoritesCompactEmptyMiddlePackagesAction(myProject, myBuilder));
     }
+    if (helper.supportsFlattenPackages()) {
+      group.addAction(new FavoritesAbbreviatePackageNamesAction(myProject, myBuilder));
+    }
+    if (!PlatformUtils.isAppCode()) {
+      group.add(new FavoritesShowMembersAction(myProject, myBuilder));
+    }
 
     final FavoritesAutoscrollFromSourceHandler handler = new FavoritesAutoscrollFromSourceHandler(myProject, myBuilder);
     handler.install();
diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesViewSettings.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesViewSettings.java
index 915d59df0440..4870d4e605b2 100644
--- a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesViewSettings.java
+++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesViewSettings.java
@@ -39,6 +39,9 @@ public class FavoritesViewSettings implements ViewSettings {
   @PropertyName("favorites.view.settings.hide.empty.middle.packages")
   public boolean myHideEmptyMiddlePackages = true;
 
+  @PropertyName("favorites.view.settings.abbreviate.qualified.package.names")
+  public boolean myAbbreviateQualifiedPackages = false;
+
 
   public FavoritesViewSettings() {
     PropertiesComponent.getInstance().loadFields(this);
@@ -89,7 +92,7 @@ public class FavoritesViewSettings implements ViewSettings {
 
   @Override
   public boolean isAbbreviatePackageNames() {
-    return false;
+    return myAbbreviateQualifiedPackages;
   }
 
   @Override
@@ -115,4 +118,9 @@ public class FavoritesViewSettings implements ViewSettings {
     myHideEmptyMiddlePackages = hide;
     save();
   }
+
+  public void setAbbreviateQualifiedPackages(boolean abbreviate) {
+    myAbbreviateQualifiedPackages = abbreviate;
+    save();
+  }
 }
diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesAbbreviatePackageNamesAction.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesAbbreviatePackageNamesAction.java
new file mode 100644
index 000000000000..ea686dd178ab
--- /dev/null
+++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesAbbreviatePackageNamesAction.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2000-2013 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.ide.favoritesTreeView.actions;
+
+import com.intellij.icons.AllIcons;
+import com.intellij.ide.IdeBundle;
+import com.intellij.ide.favoritesTreeView.FavoritesViewTreeBuilder;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.project.Project;
+
+/**
+ * User: Vassiliy.Kudryashov
+ */
+public class FavoritesAbbreviatePackageNamesAction extends FavoritesToolbarButtonAction {
+  public FavoritesAbbreviatePackageNamesAction(Project project, FavoritesViewTreeBuilder builder) {
+    super(project, builder, IdeBundle.message("action.abbreviate.qualified.package.names"), AllIcons.ObjectBrowser.AbbreviatePackageNames);
+  }
+
+  @Override
+  public boolean isOptionEnabled() {
+    return getViewSettings().isAbbreviatePackageNames();
+  }
+
+  @Override
+  public void setOption(boolean enabled) {
+    getViewSettings().setAbbreviateQualifiedPackages(enabled);
+  }
+
+  @Override
+  public void updateButton(AnActionEvent e) {
+    super.updateButton(e);
+    setVisible(getViewSettings().isFlattenPackages());
+  }
+}
diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesCompactEmptyMiddlePackagesAction.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesCompactEmptyMiddlePackagesAction.java
index 38e73a631048..9781ff8d4249 100644
--- a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesCompactEmptyMiddlePackagesAction.java
+++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesCompactEmptyMiddlePackagesAction.java
@@ -18,12 +18,35 @@ package com.intellij.ide.favoritesTreeView.actions;
 import com.intellij.icons.AllIcons;
 import com.intellij.ide.IdeBundle;
 import com.intellij.ide.favoritesTreeView.FavoritesViewTreeBuilder;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.project.Project;
 
 /**
  * @author Konstantin Bulenkov
  */
 public class FavoritesCompactEmptyMiddlePackagesAction extends FavoritesToolbarButtonAction {
+  public FavoritesCompactEmptyMiddlePackagesAction(Project project, FavoritesViewTreeBuilder builder) {
+    super(project, builder,
+          IdeBundle.message("action.compact.empty.middle.packages"),
+          AllIcons.ObjectBrowser.CompactEmptyPackages);
+  }
+
+  @Override
+  public void updateButton(AnActionEvent e) {
+    super.updateButton(e);
+    Presentation presentation = e.getPresentation();
+    if (getViewSettings().isFlattenPackages()) {
+      presentation.setText(IdeBundle.message("action.hide.empty.middle.packages"));
+      presentation.setDescription(IdeBundle.message("action.show.hide.empty.middle.packages"));
+    }
+    else {
+      presentation.setText(IdeBundle.message("action.compact.empty.middle.packages"));
+      presentation.setDescription(IdeBundle.message("action.show.compact.empty.middle.packages"));
+    }
+
+  }
+
   @Override
   public boolean isOptionEnabled() {
     return getViewSettings().isHideEmptyMiddlePackages();
@@ -33,10 +56,4 @@ public class FavoritesCompactEmptyMiddlePackagesAction extends FavoritesToolbarB
   public void setOption(boolean hide) {
     getViewSettings().setHideEmptyMiddlePackages(hide);
   }
-
-  public FavoritesCompactEmptyMiddlePackagesAction(Project project, FavoritesViewTreeBuilder builder) {
-    super(project, builder,
-          IdeBundle.message("action.compact.empty.middle.packages"),
-          AllIcons.ObjectBrowser.CompactEmptyPackages);
-  }
 }

From 372aac3a583bb205dfc98fccadd8cbb4d54accb7 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 14:24:04 +0100
Subject: [PATCH 130/354] let it be Show Log on all platforms

---
 .../src/com/intellij/ide/actions/ShowLogAction.java           | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java b/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
index 02c2526c3344..33eae3e47f7a 100644
--- a/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
+++ b/platform/platform-impl/src/com/intellij/ide/actions/ShowLogAction.java
@@ -20,7 +20,6 @@ import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.project.DumbAware;
-import com.intellij.openapi.util.SystemInfo;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
@@ -40,11 +39,10 @@ public class ShowLogAction extends AnAction implements DumbAware {
     Presentation presentation = e.getPresentation();
     presentation.setVisible(ShowFilePathAction.isSupported());
     presentation.setText(getActionName());
-    presentation.setDescription("Show Log in file manager");
   }
 
   @NotNull
   public static String getActionName() {
-    return SystemInfo.isMac ? "Reveal Log in Finder" : "Reveal Log in " + ShowFilePathAction.getFileManagerName();
+    return "Show Log in " + ShowFilePathAction.getFileManagerName();
   }
 }

From d1602ce473d0d78060e073d870e61b144bdda2ec Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 14:40:53 +0100
Subject: [PATCH 131/354] SOE

---
 .../impl/source/resolve/PsiResolveHelperImpl.java  | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
index 5c5aa513970b..6f0b5c6a4ec4 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
@@ -1202,12 +1202,22 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
       final PsiExpression elseExpression = ((PsiConditionalExpression)parent).getElseExpression();
       final PsiType[] paramTypes = {((PsiMethod)typeParameter.getOwner()).getReturnType()};
       if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(elseExpression)) && thenExpression != null) {
-        final PsiType thenType = thenExpression.getType();
+        final PsiType thenType = ourGraphGuard.doPreventingRecursion(thenExpression, true, new Computable<PsiType>() {
+          @Override
+          public PsiType compute() {
+            return thenExpression.getType();
+          }
+        });
         if (thenType != null) {
           pair = inferTypeForMethodTypeParameterInner(typeParameter, paramTypes, new PsiType[] {thenType}, substitutor, null, policy);
         }
       } else if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(thenExpression)) && elseExpression != null) {
-        final PsiType elseType = elseExpression.getType();
+        final PsiType elseType = ourGraphGuard.doPreventingRecursion(elseExpression, true, new Computable<PsiType>() {
+          @Override
+          public PsiType compute() {
+            return elseExpression.getType(); 
+          }
+        });
         if (elseType != null) {
           pair = inferTypeForMethodTypeParameterInner(typeParameter, paramTypes, new PsiType[] {elseType}, substitutor, null, policy);
         }

From 0a181f6faa9011dddbdd2865dbbd320554b0be4d Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 14:46:31 +0100
Subject: [PATCH 132/354] dfa inspection: more logging

---
 .../codeInspection/dataFlow/DataFlowRunner.java       | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
index 94c628ff0f1d..4328827ad07d 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
@@ -103,6 +103,7 @@ public class DataFlowRunner {
       myFields = flow.getFields();
 
       if (LOG.isDebugEnabled()) {
+        LOG.debug("Analyzing code block: " + psiBlock.getText());
         for (int i = 0; i < myInstructions.length; i++) {
           Instruction instruction = myInstructions[i];
           LOG.debug(i + ": " + instruction.toString());
@@ -111,6 +112,7 @@ public class DataFlowRunner {
 
       Integer tooExpensiveSize = psiBlock.getUserData(TOO_EXPENSIVE_SIZE);
       if (tooExpensiveSize != null && tooExpensiveSize == psiBlock.getText().hashCode()) {
+        LOG.debug("Too complex because hasn't changed since being too complex already");
         return RunnerResult.TOO_COMPLEX;
       }
 
@@ -125,6 +127,7 @@ public class DataFlowRunner {
       int count = 0;
       while (!queue.isEmpty()) {
         if (count % 50 == 0 && !unitTestMode && measurer.isTimeOver()) {
+          LOG.debug("Too complex because the analysis took too long");
           psiBlock.putUserData(TOO_EXPENSIVE_SIZE, psiBlock.getText().hashCode());
           return RunnerResult.TOO_COMPLEX;
         }
@@ -140,6 +143,7 @@ public class DataFlowRunner {
 
         if (instruction instanceof BranchingInstruction) {
           if (!instruction.setMemoryStateProcessed(instructionState.getMemoryState().createCopy())) {
+            LOG.debug("Too complex because too many different possible states");
             return RunnerResult.TOO_COMPLEX; // Too complex :(
           }
         }
@@ -163,14 +167,17 @@ public class DataFlowRunner {
       }
 
       psiBlock.putUserData(TOO_EXPENSIVE_SIZE, null);
+      LOG.debug("Analysis ok");
       return RunnerResult.OK;
     }
     catch (ArrayIndexOutOfBoundsException e) {
-      LOG.error(psiBlock.getText(), e); /* TODO[max] !!! hack (of 18186). Please fix in better times. */
+      LOG.error(psiBlock.getText(), e); // TODO fix in better times
       return RunnerResult.ABORTED;
     }
     catch (EmptyStackException e) {
-      //LOG.error(psiBlock.getText(), e); /* TODO[max] !!! hack (of 18186). Please fix in better times. */
+      if (LOG.isDebugEnabled()) {
+        LOG.error(e); // TODO fix in better times
+      }
       return RunnerResult.ABORTED;
     }
   }

From 654be3ea25c2291fe3fe6498510bf085a1b87769 Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Mon, 25 Feb 2013 17:48:03 +0400
Subject: [PATCH 133/354] WEB-6807 Emmet: expanding CSS property that starts
 with 's' with vendor prefix results in incorrect property name

---
 .../intellij/application/options/emmet/CssPrefixInfo.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java b/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
index f31443ce9e4b..4f67b14423c4 100644
--- a/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
+++ b/xml/impl/src/com/intellij/application/options/emmet/CssPrefixInfo.java
@@ -94,6 +94,14 @@ public class CssPrefixInfo {
     return result;
   }
 
+  @Override
+  public String toString() {
+    return "CssPrefixInfo{" +
+           "myPropertyName='" + myPropertyName + '\'' +
+           ", myEnabledPrefixes=" + myEnabledPrefixes +
+           '}';
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;

From d1fde5c3c3d6cbf0470ad4164d06534d9f08abe1 Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Mon, 25 Feb 2013 17:52:32 +0400
Subject: [PATCH 134/354] IDEA-101805 Data Source Properties / Advanced: Quick
 Search in sorted table works incorrectly

---
 .../platform-impl/src/com/intellij/ui/TableSpeedSearch.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/ui/TableSpeedSearch.java b/platform/platform-impl/src/com/intellij/ui/TableSpeedSearch.java
index b90952db8ec6..5ed5694d8b9e 100644
--- a/platform/platform-impl/src/com/intellij/ui/TableSpeedSearch.java
+++ b/platform/platform-impl/src/com/intellij/ui/TableSpeedSearch.java
@@ -87,9 +87,9 @@ public class TableSpeedSearch extends SpeedSearchBase<JTable> {
   protected String getElementText(Object element) {
     final int index = ((Integer)element).intValue();
     final TableModel model = myComponent.getModel();
-    int row = index / model.getColumnCount();
-    int col = index % model.getColumnCount();
-    final Object value = model.getValueAt(row, col);
+    int row = myComponent.convertRowIndexToModel(index / model.getColumnCount());
+    int col = myComponent.convertColumnIndexToModel(index % model.getColumnCount());
+    Object value = model.getValueAt(row, col);
     return myToStringConvertor.fun(value, new Cell(row, col));
   }
 

From 3ef20298650f4050e8e69031517331e4e05d90d9 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 14:52:36 +0100
Subject: [PATCH 135/354] don't select anything when implementing a method with
 no range or text

---
 .../codeInsight/hint/ImplementationViewComponent.java        | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java b/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
index 715fd486f772..8a7bd9f7b796 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
@@ -420,6 +420,7 @@ public class ImplementationViewComponent extends JPanel {
   }
 
 
+  @Nullable
   public static String getNewText(PsiElement elt) {
     Project project = elt.getProject();
     PsiFile psiFile = getContainingFile(elt);
@@ -427,6 +428,10 @@ public class ImplementationViewComponent extends JPanel {
     final Document doc = PsiDocumentManager.getInstance(project).getDocument(psiFile);
     if (doc == null) return null;
 
+    if (elt.getText() == null || elt.getTextRange() == null) {
+      return null;
+    }
+
     final ImplementationTextSelectioner implementationTextSelectioner =
       LanguageImplementationTextSelectioner.INSTANCE.forLanguage(elt.getLanguage());
     int start = implementationTextSelectioner.getTextStartOffset(elt);

From edaaa853753148279cfb9a0eed704e896b9480c0 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 15:17:51 +0100
Subject: [PATCH 136/354] IDEA-101815 Splitter divider is white on Windows

---
 ...MetalTheme.java => DarculaMetalTheme.java} | 46 ++++++++++++-------
 .../intellij/ide/ui/laf/LafManagerImpl.java   |  3 +-
 .../ide/ui/laf/darcula/DarculaLaf.java        |  4 +-
 .../ide/ui/laf/darcula/darcula.properties     |  2 +
 4 files changed, 36 insertions(+), 19 deletions(-)
 rename platform/platform-impl/src/com/intellij/ide/ui/laf/{IdeaDarkMetalTheme.java => DarculaMetalTheme.java} (71%)

diff --git a/platform/platform-impl/src/com/intellij/ide/ui/laf/IdeaDarkMetalTheme.java b/platform/platform-impl/src/com/intellij/ide/ui/laf/DarculaMetalTheme.java
similarity index 71%
rename from platform/platform-impl/src/com/intellij/ide/ui/laf/IdeaDarkMetalTheme.java
rename to platform/platform-impl/src/com/intellij/ide/ui/laf/DarculaMetalTheme.java
index e891f4e91f76..25937fa14835 100644
--- a/platform/platform-impl/src/com/intellij/ide/ui/laf/IdeaDarkMetalTheme.java
+++ b/platform/platform-impl/src/com/intellij/ide/ui/laf/DarculaMetalTheme.java
@@ -1,6 +1,6 @@
 
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -16,8 +16,7 @@
  */
 package com.intellij.ide.ui.laf;
 
-import com.intellij.ui.UIBundle;
-
+import javax.swing.*;
 import javax.swing.plaf.ColorUIResource;
 import javax.swing.plaf.metal.DefaultMetalTheme;
 import java.awt.*;
@@ -25,27 +24,46 @@ import java.awt.*;
 /**
  * @author Konstantin Bulenkov
  */
-public class IdeaDarkMetalTheme extends DefaultMetalTheme {
-  public String getName() {
-    return UIBundle.message("idea.blue.metal.theme.name");
-  }
+public class DarculaMetalTheme extends DefaultMetalTheme {
 
-  private static final ColorUIResource darkGray = new ColorUIResource(132, 130, 132);
+  private final ColorUIResource myControlHighlightColor = new ColorUIResource(108, 111, 113);
+  private final ColorUIResource myControlDarkShadowColor = new ColorUIResource(39, 42, 44);
+  private final ColorUIResource myControlColor = new ColorUIResource(UIManager.getColor("control"));
   private static final ColorUIResource white = new ColorUIResource(255, 255, 255);
   private static final ColorUIResource darkBlue = new ColorUIResource(82, 108, 164);
-  //  private static ColorUIResource lightGray = new ColorUIResource(214, 211, 206);
   private static final ColorUIResource lightGray = new ColorUIResource(214, 214, 214);
+  private final ColorUIResource mySeparatorForeground = new ColorUIResource(53, 56, 58);
+
+  public static final ColorUIResource primary1 = new ColorUIResource(53, 56, 58);
+  private static final ColorUIResource primary2 = new ColorUIResource(91, 135, 206);
+  private static final ColorUIResource primary3 = new ColorUIResource(166, 202, 240);
+
+
+
+  public String getName() {
+    return "Darcula theme";
+  }
 
   public ColorUIResource getControl() {
-    return lightGray;
+    return myControlColor;
+  }
+
+  @Override
+  public ColorUIResource getControlHighlight() {
+    return myControlHighlightColor;
+  }
+
+  @Override
+  public ColorUIResource getControlDarkShadow() {
+    return myControlDarkShadowColor;
   }
 
   public ColorUIResource getSeparatorBackground() {
-    return white;
+    return getControl();
   }
 
   public ColorUIResource getSeparatorForeground() {
-    return darkGray;
+    return mySeparatorForeground;
   }
 
   public ColorUIResource getMenuBackground() {
@@ -64,10 +82,6 @@ public class IdeaDarkMetalTheme extends DefaultMetalTheme {
     return white;
   }
 
-  public static final ColorUIResource primary1 = new ColorUIResource(10, 36, 106);
-  private static final ColorUIResource primary2 = new ColorUIResource(91, 135, 206);
-  private static final ColorUIResource primary3 = new ColorUIResource(166, 202, 240);
-
   public ColorUIResource getFocusColor() {
     return new ColorUIResource(Color.black);
   }
diff --git a/platform/platform-impl/src/com/intellij/ide/ui/laf/LafManagerImpl.java b/platform/platform-impl/src/com/intellij/ide/ui/laf/LafManagerImpl.java
index c3d7661d9e42..0a7752d3383a 100644
--- a/platform/platform-impl/src/com/intellij/ide/ui/laf/LafManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/ide/ui/laf/LafManagerImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -344,7 +344,6 @@ public final class LafManagerImpl extends LafManager implements ApplicationCompo
     }
     else if (DarculaLookAndFeelInfo.CLASS_NAME.equals(lookAndFeelInfo.getClassName())) {
       DarculaLaf laf = new DarculaLaf();
-      MetalLookAndFeel.setCurrentTheme(new IdeaDarkMetalTheme());
       try {
         UIManager.setLookAndFeel(laf);
       }
diff --git a/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/DarculaLaf.java b/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/DarculaLaf.java
index e3efb78edfe5..fabcfaae1416 100644
--- a/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/DarculaLaf.java
+++ b/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/DarculaLaf.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,6 +15,7 @@
  */
 package com.intellij.ide.ui.laf.darcula;
 
+import com.intellij.ide.ui.laf.DarculaMetalTheme;
 import com.intellij.ide.ui.laf.IdeaLaf;
 import com.intellij.ide.ui.laf.LafManagerImpl;
 import com.intellij.openapi.util.IconLoader;
@@ -91,6 +92,7 @@ public final class DarculaLaf extends BasicLookAndFeel {
       patchComboBox(metalDefaults, defaults);
       defaults.remove("Spinner.arrowButtonBorder");
       defaults.put("Spinner.arrowButtonSize", new Dimension(16, 5));
+      MetalLookAndFeel.setCurrentTheme(new DarculaMetalTheme());
       return defaults;
     }
     catch (Exception ignore) {
diff --git a/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/darcula.properties b/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/darcula.properties
index c558d085f8b9..91eeaafa552e 100644
--- a/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/darcula.properties
+++ b/platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/darcula.properties
@@ -89,6 +89,8 @@ Spinner.background=3c3f41
 Spinner.arrowButtonInsets=1,1,1,1
 Spinner.editorBorderPainted=false
 
+SplitPane.highlight=3c3f41
+
 Hyperlink.linkColor=589df6
 
 Tree.collapsedIcon=AllIcons.Mac.Tree_white_right_arrow

From 4fa035ab95210b82c6b6f72274535c8d78feee08 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Mon, 25 Feb 2013 15:18:17 +0100
Subject: [PATCH 137/354] NPE fix

---
 platform/platform-impl/src/com/intellij/ui/ColorPicker.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/ui/ColorPicker.java b/platform/platform-impl/src/com/intellij/ui/ColorPicker.java
index 3915251adec7..1caac70409a5 100644
--- a/platform/platform-impl/src/com/intellij/ui/ColorPicker.java
+++ b/platform/platform-impl/src/com/intellij/ui/ColorPicker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -272,12 +272,14 @@ public class ColorPicker extends JPanel implements ColorListener, DocumentListen
   }
 
   private void fireColorChanged(Color color) {
+    if (myExternalListeners == null) return;
     for (ColorPickerListener listener : myExternalListeners) {
       listener.colorChanged(color);
     }
   }
 
   private void fireClosed(@Nullable Color color) {
+    if (myExternalListeners == null) return;
     for (ColorPickerListener listener : myExternalListeners) {
       listener.closed(color);
     }

From 5359032f597c3687407112ec1dc3238fdf0cca0e Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Mon, 25 Feb 2013 18:35:59 +0400
Subject: [PATCH 138/354] IDEA-101783 Throwable at
 com.intellij.execution.rmi.RemoteProcessSupport.acquire

---
 .../idea/maven/project/MavenProjectsManagerWatcher.java   | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenProjectsManagerWatcher.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenProjectsManagerWatcher.java
index 5acfe28fadad..533d46cf43c5 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenProjectsManagerWatcher.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenProjectsManagerWatcher.java
@@ -50,7 +50,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.idea.maven.model.MavenConstants;
 import org.jetbrains.idea.maven.utils.MavenMergingUpdateQueue;
-import org.jetbrains.idea.maven.utils.MavenProgressIndicator;
 import org.jetbrains.idea.maven.utils.MavenUtil;
 
 import java.io.File;
@@ -251,12 +250,7 @@ public class MavenProjectsManagerWatcher {
 
   public synchronized void setExplicitProfiles(Collection<String> profiles) {
     myProjectsTree.setExplicitProfiles(profiles);
-
-    if(myManager.getImportingSettings().isImportAutomatically()) {
-      scheduleUpdateAll(false, true);
-    } else {
-      myProjectsTree.updateAll(false, myGeneralSettings, new MavenProgressIndicator());
-    }
+    scheduleUpdateAll(false, false);
   }
 
   public void scheduleUpdateAll(boolean force, final boolean forceImportAndResolve) {

From 632bf23c396293418e88339608179eb4dc2277ca Mon Sep 17 00:00:00 2001
From: Fedor Korotkov <fedor.korotkov@jetbrains.com>
Date: Mon, 25 Feb 2013 18:49:24 +0400
Subject: [PATCH 139/354] Microdata: schema.org format support

---
 .../html/impl/util/MicrodataUtil.java         |  34 +-
 .../html/MicrodataCompletionTest.java         |  42 ++
 xml/tests/testData/microdata/Product.html     | 706 ++++++++++++++++++
 3 files changed, 776 insertions(+), 6 deletions(-)
 create mode 100644 xml/tests/testData/microdata/Product.html

diff --git a/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
index 9d91f3d69def..5467388e914a 100644
--- a/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
+++ b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
@@ -115,13 +115,20 @@ public class MicrodataUtil {
 
   private static List<String> collectNames(PsiFile file, String type) {
     if (file instanceof XmlFile) {
-      final CollectNamesVisitor collectNamesVisitor = new CollectNamesVisitor(type);
+      final CollectNamesVisitor collectNamesVisitor = getVisitorByType(type);
       file.accept(collectNamesVisitor);
       return collectNamesVisitor.getValues();
     }
     return Collections.emptyList();
   }
 
+  private static CollectNamesVisitor getVisitorByType(String type) {
+    if (type.contains("schema.org")) {
+      return new CollectNamesFromSchemaOrgVisitor();
+    }
+    return new CollectNamesByMicrodataVisitor(type);
+  }
+
   public static PsiReference[] getUrlReferencesForAttributeValue(final XmlAttributeValue element) {
     return getReferencesForAttributeValue(element, new PairFunction<String, Integer, PsiReference>() {
       @Nullable
@@ -172,12 +179,18 @@ public class MicrodataUtil {
   }
 
   private static class CollectNamesVisitor extends XmlRecursiveElementVisitor {
+    protected final Set<String> myValues = new THashSet<String>();
 
-    private final String myType;
+    public List<String> getValues() {
+      return new ArrayList<String>(myValues);
+    }
+  }
+
+  public static class CollectNamesByMicrodataVisitor extends CollectNamesVisitor {
+    protected final String myType;
     private boolean myCollecting = false;
-    private final Set<String> myValues = new THashSet<String>();
 
-    public CollectNamesVisitor(String type) {
+    public CollectNamesByMicrodataVisitor(String type) {
       myType = type;
     }
 
@@ -199,9 +212,18 @@ public class MicrodataUtil {
         myCollecting = false;
       }
     }
+  }
 
-    public List<String> getValues() {
-      return new ArrayList<String>(myValues);
+  public static class CollectNamesFromSchemaOrgVisitor extends CollectNamesVisitor {
+    @Override
+    public void visitXmlTag(XmlTag tag) {
+      super.visitXmlTag(tag);
+      if ("prop-nam".equalsIgnoreCase(getStripedAttributeValue(tag, "class"))) {
+        final String code = tag.getSubTagText("code");
+        if (code != null) {
+          myValues.add(code);
+        }
+      }
     }
   }
 
diff --git a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
index 5b40884bc054..d621b286d092 100644
--- a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
+++ b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
@@ -119,6 +119,48 @@ public class MicrodataCompletionTest extends CodeInsightFixtureTestCase {
     );
   }
 
+  public void testPropValueSchemaOrgFormat() throws Throwable {
+    final VirtualFile virtualFile = myFixture.copyFileToProject("Product.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://schema.org/Product", virtualFile.getPath());
+      }
+    });
+    doTestInHtml("<section itemscope itemtype=\"http://schema.org/Product\"><div itemprop=\"<caret>\"></div></section>",
+                 "additionalType",
+                 "aggregateRating",
+                 "brand",
+                 "color",
+                 "depth",
+                 "description",
+                 "gtin13",
+                 "gtin14",
+                 "gtin8",
+                 "height",
+                 "image",
+                 "isAccessoryOrSparePartFor",
+                 "isConsumableFor",
+                 "isRelatedTo",
+                 "isSimilarTo",
+                 "itemCondition",
+                 "logo",
+                 "manufacturer",
+                 "model",
+                 "mpn",
+                 "name",
+                 "offers",
+                 "productID",
+                 "releaseDate",
+                 "review",
+                 "reviews",
+                 "sku",
+                 "url",
+                 "weight",
+                 "width"
+    );
+  }
+
   public void testPropValueFromTwoTypes() throws Throwable {
     final VirtualFile personFile = myFixture.copyFileToProject("Person.html");
     final VirtualFile addressFile = myFixture.copyFileToProject("Address.html");
diff --git a/xml/tests/testData/microdata/Product.html b/xml/tests/testData/microdata/Product.html
new file mode 100644
index 000000000000..f8fac536ee77
--- /dev/null
+++ b/xml/tests/testData/microdata/Product.html
@@ -0,0 +1,706 @@
+
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>Product  - schema.org</title>
+
+    <meta name="description" content="Schema.org is a set of extensible
+    schemas that enables webmasters to embed
+    structured data on their web pages for use by search engines and
+    other applications.">
+    <link rel="stylesheet" type="text/css"
+          href="search_files/schemaorg.css">
+
+    <link href="search_files/prettify.css" type="text/css"
+          rel="stylesheet" />
+    <script type="text/javascript" src="js/prettify.js">
+    </script>
+    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js"></script>
+
+<script type="text/javascript">
+      $(document).ready(function(){
+        prettyPrint();
+        setTimeout(function(){
+
+  $(".atn:contains(itemscope), .atn:contains(itemtype), .atn:contains(itemprop), .atn:contains(itemid), .atn:contains(time), .atn:contains(datetime), .atn:contains(datetime), .tag:contains(time) ").addClass('new');
+  $('.new + .pun + .atv').addClass('curl');
+
+        }, 500);
+      });
+</script>
+
+<style>
+
+  .pln    { color: #444;    } /* plain text                 */
+  .tag    { color: #515484; } /* div, span, a, etc          */
+  .atn,
+  .atv    { color: #314B17; } /* href, datetime             */
+  .new    { color: #660003; } /* itemscope, itemtype, etc,. */
+  .curl   { color: #080;    } /* new url                    */
+
+</style>
+
+</head>
+<body>
+    <div id="container">
+        <div id="intro">
+            <div id="pageHeader">
+              <div class="wrapper">
+                <h1>schema.org</h1>
+
+<div id="cse-search-form" style="width: 400px;"></div>
+
+<script type="text/javascript" src="http://www.google.com/jsapi"></script>
+<script type="text/javascript">
+  google.load('search', '1', {language : 'en', style : google.loader.themes.ESPRESSO});
+  google.setOnLoadCallback(function() {
+    var customSearchControl = new google.search.CustomSearchControl('013516846811604855281:nj5laplixaa');
+    customSearchControl.setResultSetSize(google.search.Search.FILTERED_CSE_RESULTSET);
+    var options = new google.search.DrawOptions();
+    options.enableSearchboxOnly("docs/search_results.html", null, false, '#');
+    customSearchControl.draw('cse-search-form', options);
+  }, true);
+</script>
+
+
+              </div>
+            </div>
+        </div>
+    </div>
+
+            <div id="selectionbar">
+               <div class="wrapper">
+                <ul>
+                    <li >
+                      <a href="docs/documents.html">Documentation</a></li>
+                    <li class="activelink">
+                      <a href="docs/schemas.html">Schemas</a></li>
+                    <li >
+                      <a href=".">Home</a></li>
+                </ul>
+                </div>
+
+            </div>
+        <div style="padding: 14px; float: right;" id="languagebox"></div>
+
+  <div id="mainContent">
+
+
+  <h1 class="page-title">
+
+
+      <a href=Thing>Thing</a>
+
+      &gt;
+      <a href=Product>Product</a>
+
+  </h1>
+  A product is anything that is made available for sale—for example, a pair of shoes, a concert ticket, or a car. Commodity services, like haircuts, can also be represented using this type.
+
+
+
+        <table cellspacing="3" class="definition-table">
+        <thead><tr><th>Property</th><th>Expected Type</th><th>Description</th>
+               </tr></thead>
+
+
+        <thead class="supertype"><tr>
+            <th class="supertype-name" colspan="3">Properties from <a href="Thing">Thing</a></th></tr></thead>
+        <tbody class="supertype">
+
+
+        <tr><th class="prop-nam" scope="row">
+          <code>additionalType</code></th>
+          <td class="prop-ect">
+
+
+
+                URL
+
+
+          </td>
+          <td class="prop-desc">An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>description</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">A short description of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>image</code></th>
+          <td class="prop-ect">
+
+
+
+                URL
+
+
+          </td>
+          <td class="prop-desc">URL of an image of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>name</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The name of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>url</code></th>
+          <td class="prop-ect">
+
+
+
+                URL
+
+
+          </td>
+          <td class="prop-desc">URL of the item.</td>
+        </tr>
+
+
+
+
+
+        <thead class="supertype"><tr>
+            <th class="supertype-name" colspan="3">Properties from <a href="Product">Product</a></th></tr></thead>
+        <tbody class="supertype">
+
+
+        <tr><th class="prop-nam" scope="row">
+          <code>aggregateRating</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=AggregateRating>AggregateRating</a>
+
+
+          </td>
+          <td class="prop-desc">The overall rating, based on a collection of reviews or ratings, of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>brand</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Brand>Brand</a>
+
+
+              or
+
+                <a href=Organization>Organization</a>
+
+
+          </td>
+          <td class="prop-desc">The brand(s) associated with a product or service, or the brand(s) maintained by an organization or business person.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>color</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The color of the product.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>depth</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Distance>Distance</a>
+
+
+              or
+
+                <a href=QuantitativeValue>QuantitativeValue</a>
+
+
+          </td>
+          <td class="prop-desc">The depth of the product.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>gtin13</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The GTIN-13 code of the product, or the product to which the offer refers. This is equivalent to 13-digit ISBN codes and EAN UCC-13. Former 12-digit UPC codes can be converted into a GTIN-13 code by simply adding a preceeding zero.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>gtin14</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The GTIN-14 code of the product, or the product to which the offer refers.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>gtin8</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The GTIN-8 code of the product, or the product to which the offer refers. This code is also known as EAN/UCC-8 or 8-digit EAN.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>height</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Distance>Distance</a>
+
+
+              or
+
+                <a href=QuantitativeValue>QuantitativeValue</a>
+
+
+          </td>
+          <td class="prop-desc">The height of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>isAccessoryOrSparePartFor</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Product>Product</a>
+
+
+          </td>
+          <td class="prop-desc">A pointer to another product (or multiple products) for which this product is an accessory or spare part.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>isConsumableFor</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Product>Product</a>
+
+
+          </td>
+          <td class="prop-desc">A pointer to another product (or multiple products) for which this product is a consumable.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>isRelatedTo</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Product>Product</a>
+
+
+          </td>
+          <td class="prop-desc">A pointer to another, somehow related product (or multiple products).</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>isSimilarTo</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Product>Product</a>
+
+
+          </td>
+          <td class="prop-desc">A pointer to another, functionally similar product (or multiple products).</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>itemCondition</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=OfferItemCondition>OfferItemCondition</a>
+
+
+          </td>
+          <td class="prop-desc">A predefined value from OfferItemCondition or a textual description of the condition of the product or service, or the products or services included in the offer.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>logo</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=ImageObject>ImageObject</a>
+
+
+              or
+
+                URL
+
+
+          </td>
+          <td class="prop-desc">URL of an image for the logo of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>manufacturer</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Organization>Organization</a>
+
+
+          </td>
+          <td class="prop-desc">The manufacturer of the product.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>model</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=ProductModel>ProductModel</a>
+
+
+              or
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The model of the product. Use with the URL of a ProductModel or a textual representation of the model identifier. The URL of the ProductModel can be from an external source. It is recommended to additionally provide strong product identifiers via the gtin8/gtin13/gtin14 and mpn properties.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>mpn</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The Manufacturer Part Number (MPN) of the product, or the product to which the offer refers.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>offers</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Offer>Offer</a>
+
+
+          </td>
+          <td class="prop-desc">An offer to sell this item&#x2014;for example, an offer to sell a product, the DVD of a movie, or tickets to an event.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>productID</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The product identifier, such as ISBN. For example: <code>&lt;meta itemprop='productID' content='isbn:123-456-789'/&gt;</code>.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>releaseDate</code></th>
+          <td class="prop-ect">
+
+
+
+                Date
+
+
+          </td>
+          <td class="prop-desc">The release date of a product or product model. This can be used to distinguish the exact variant of a product.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>review</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Review>Review</a>
+
+
+          </td>
+          <td class="prop-desc">A review of the item.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>reviews</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Review>Review</a>
+
+
+          </td>
+          <td class="prop-desc">Review of the item (legacy spelling; see singular form, review).</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>sku</code></th>
+          <td class="prop-ect">
+
+
+
+                Text
+
+
+          </td>
+          <td class="prop-desc">The Stock Keeping Unit (SKU), i.e. a merchant-specific identifier for a product or service, or the product to which the offer refers.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>weight</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=QuantitativeValue>QuantitativeValue</a>
+
+
+          </td>
+          <td class="prop-desc">The weight of the product.</td>
+        </tr>
+
+        <tr><th class="prop-nam" scope="row">
+          <code>width</code></th>
+          <td class="prop-ect">
+
+
+
+                <a href=Distance>Distance</a>
+
+
+              or
+
+                <a href=QuantitativeValue>QuantitativeValue</a>
+
+
+          </td>
+          <td class="prop-desc">The width of the item.</td>
+        </tr>
+
+
+         </table>
+
+
+
+
+  <h3>More specific types</h3>
+  <ul>
+
+    <li><a href=IndividualProduct>IndividualProduct</a>
+
+    <li><a href=ProductModel>ProductModel</a>
+
+    <li><a href=SomeProducts>SomeProducts</a>
+
+  </ul>
+
+
+
+
+
+  <div class="attrib">This class contains derivatives of properties from the GoodRelations Vocabulary for E-Commerce, created by Martin Hepp. GoodRelations is a data model for sharing e-commerce data on the Web that can be expressed in a variety of syntaxes, including RDFa and HTML5 Microdata. More information about GoodRelations can be found at <a href="http://purl.org/goodrelations/">http://purl.org/goodrelations/</a>.</div>
+
+
+<div class="version">Schema Draft Version 0.99</div>
+
+  <hr>
+  <b>Example 1</b>
+  <p><b>Original HTML:</b>
+  <pre class="prettyprint lang-html linenums">
+Kenmore White 17" Microwave
+&lt;img src="kenmore-microwave-17in.jpg" alt='Kenmore 17" Microwave' /&gt;
+Rated 3.5/5 based on 11 customer reviews
+
+$55.00
+In stock
+
+Product description:
+0.7 cubic feet countertop microwave. Has six preset cooking categories and
+ convenience features like Add-A-Minute and Child Lock.
+
+Customer reviews:
+
+Not a happy camper - by Ellie, April 1, 2011
+1/5 stars
+The lamp burned out and now I have to replace it.
+
+ Value purchase - by Lucas, March 25, 2011
+4/5 stars
+Great microwave for the price. It is small and fits in my apartment.
+...
+</pre>
+  <br><br><b>With Microdata:</b>
+  <pre  class="prettyprint lang-html linenums">
+&lt;div itemscope itemtype="http://schema.org/Product"&gt;
+  &lt;span itemprop="name"&gt;Kenmore White 17" Microwave&lt;/span&gt;
+  &lt;img src="kenmore-microwave-17in.jpg" alt='Kenmore 17" Microwave' /&gt;
+  &lt;div itemprop="aggregateRating"
+    itemscope itemtype="http://schema.org/AggregateRating"&gt;
+   Rated &lt;span itemprop="ratingValue"&gt;3.5&lt;/span&gt;/5
+   based on &lt;span itemprop="reviewCount"&gt;11&lt;/span&gt; customer reviews
+  &lt;/div&gt;
+
+  &lt;div itemprop="offers" itemscope itemtype="http://schema.org/Offer"&gt;
+    &lt;span itemprop="price"&gt;$55.00&lt;/span&gt;
+    &lt;link itemprop="availability" href="http://schema.org/InStock" /&gt;In stock
+  &lt;/div&gt;
+
+  Product description:
+  &lt;span itemprop="description"&gt;0.7 cubic feet countertop microwave.
+  Has six preset cooking categories and convenience features like
+  Add-A-Minute and Child Lock.&lt;/span&gt;
+
+  Customer reviews:
+
+  &lt;div itemprop="review" itemscope itemtype="http://schema.org/Review"&gt;
+    &lt;span itemprop="name"&gt;Not a happy camper&lt;/span&gt; -
+    by &lt;span itemprop="author"&gt;Ellie&lt;/span&gt;,
+    &lt;meta itemprop="datePublished" content="2011-04-01"&gt;April 1, 2011
+    &lt;div itemprop="reviewRating" itemscope itemtype="http://schema.org/Rating"&gt;
+      &lt;meta itemprop="worstRating" content = "1"&gt;
+      &lt;span itemprop="ratingValue"&gt;1&lt;/span&gt;/
+      &lt;span itemprop="bestRating"&gt;5&lt;/span&gt;stars
+    &lt;/div&gt;
+    &lt;span itemprop="description"&gt;The lamp burned out and now I have to replace
+    it. &lt;/span&gt;
+  &lt;/div&gt;
+
+  &lt;div itemprop="review" itemscope itemtype="http://schema.org/Review"&gt;
+    &lt;span itemprop="name"&gt;Value purchase&lt;/span&gt; -
+    by &lt;span itemprop="author"&gt;Lucas&lt;/span&gt;,
+    &lt;meta itemprop="datePublished" content="2011-03-25"&gt;March 25, 2011
+    &lt;div itemprop="reviewRating" itemscope itemtype="http://schema.org/Rating"&gt;
+      &lt;meta itemprop="worstRating" content = "1"/&gt;
+      &lt;span itemprop="ratingValue"&gt;4&lt;/span&gt;/
+      &lt;span itemprop="bestRating"&gt;5&lt;/span&gt;stars
+    &lt;/div&gt;
+    &lt;span itemprop="description"&gt;Great microwave for the price. It is small and
+    fits in my apartment.&lt;/span&gt;
+  &lt;/div&gt;
+  ...
+&lt;/div&gt;
+</pre>
+
+  <hr>
+  <b>Example 2</b>
+  <p><b>Original HTML:</b>
+  <pre class="prettyprint lang-html linenums">
+&lt;img src="dell-30in-lcd.jpg" /&gt;
+Dell UltraSharp 30" LCD Monitor
+
+87 out of 100 based on 24 user ratings
+
+$1250 to $1495 from 8 sellers
+
+Sellers:
+&lt;a href="save-a-lot-monitors.com/dell-30.html"&gt;
+  Save A Lot Monitors - $1250&lt;/a&gt;
+&lt;a href="jondoe-gadgets.com/dell-30.html"&gt;
+  Jon Doe's Gadgets - $1350&lt;/a&gt;
+...
+</pre>
+  <br><br><b>With Microdata:</b>
+  <pre  class="prettyprint lang-html linenums">
+&lt;div itemscope itemtype="http://schema.org/Product"&gt;
+  &lt;img itemprop="image" src="dell-30in-lcd.jpg" /&gt;
+  &lt;span itemprop="name"&gt;Dell UltraSharp 30" LCD Monitor&lt;/span&gt;
+
+  &lt;div itemprop="aggregateRating"
+    itemscope itemtype="http://schema.org/AggregateRating"&gt;
+    &lt;span itemprop="ratingValue"&gt;87&lt;/span&gt;
+    out of &lt;span itemprop="bestRating"&gt;100&lt;/span&gt;
+    based on &lt;span itemprop="ratingCount"&gt;24&lt;/span&gt; user ratings
+  &lt;/div&gt;
+
+  &lt;div itemprop="offers" itemscope itemtype="http://schema.org/AggregateOffer"&gt;
+    &lt;span itemprop="lowPrice"&gt;$1250&lt;/span&gt;
+    to &lt;span itemprop="highPrice"&gt;$1495&lt;/span&gt;
+    from &lt;span itemprop="offerCount"&gt;8&lt;/span&gt; sellers
+
+  Sellers:
+  &lt;div itemprop="offers" itemscope itemtype="http://schema.org/Offer"&gt;
+    &lt;a itemprop="url" href="save-a-lot-monitors.com/dell-30.html"&gt;
+     Save A Lot Monitors - $1250&lt;/a&gt;
+  &lt;/div&gt;
+  &lt;div itemprop="offers" itemscope itemtype="http://schema.org/Offer"&gt;
+    &lt;a itemprop="url" href="jondoe-gadgets.com/dell-30.html"&gt;
+     Jon Doe's Gadgets - $1350&lt;/a&gt;
+  &lt;/div&gt;
+  ...
+&lt;/div&gt;
+</pre>
+
+<br><br>
+
+
+  </div>
+
+
+<div id="footer"><p>
+  <a href="docs/terms.html">Terms and conditions</a></p>
+</div>
+
+</body>
+</html>
\ No newline at end of file

From 501e96dc5877784393737d1e9cf02cb224de0bb4 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Mon, 25 Feb 2013 20:02:03 +0400
Subject: [PATCH 140/354] RUBY-13074 Cannot Rerun Nailgun Server in the Run
 tool window

---
 .../intellij/execution/ExecutionManager.java  |  4 +--
 .../runners/ExecutionEnvironmentBuilder.java  |  1 +
 .../execution/impl/ExecutionManagerImpl.java  | 35 ++++++++++++++-----
 .../execution/runners/RestartAction.java      | 11 ++----
 4 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/execution/ExecutionManager.java b/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
index 3c2c875f4fed..1979a7d123b3 100644
--- a/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
+++ b/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
@@ -52,13 +52,13 @@ public abstract class ExecutionManager {
   public abstract void restartRunProfile(@NotNull Project project,
                                          @NotNull Executor executor,
                                          @NotNull ExecutionTarget target,
-                                         @NotNull RunnerAndConfigurationSettings configuration,
+                                         @Nullable RunnerAndConfigurationSettings configuration,
                                          @Nullable ProcessHandler processHandler);
 
   //currentDescriptor is null for toolbar/popup action and not null for actions in run/debug toolwindows
   public abstract void restartRunProfile(@NotNull Project project,
                                          @NotNull Executor executor,
                                          @NotNull ExecutionTarget target,
-                                         @NotNull RunnerAndConfigurationSettings configuration,
+                                         @Nullable RunnerAndConfigurationSettings configuration,
                                          @Nullable RunContentDescriptor currentDescriptor);
 }
diff --git a/platform/lang-api/src/com/intellij/execution/runners/ExecutionEnvironmentBuilder.java b/platform/lang-api/src/com/intellij/execution/runners/ExecutionEnvironmentBuilder.java
index 378f4063d8fb..6f1017af470b 100644
--- a/platform/lang-api/src/com/intellij/execution/runners/ExecutionEnvironmentBuilder.java
+++ b/platform/lang-api/src/com/intellij/execution/runners/ExecutionEnvironmentBuilder.java
@@ -96,6 +96,7 @@ public final class ExecutionEnvironmentBuilder {
     return this;
   }
 
+  @NotNull
   public ExecutionEnvironment build() {
     ExecutionEnvironment environment =
       new ExecutionEnvironment(myRunProfile, myTarget, myProject, myRunnerSettings, myConfigurationSettings, myContentToReuse,
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
index 333683dcb07a..62873194e340 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
@@ -261,7 +261,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   public void restartRunProfile(@NotNull final Project project,
                                 @NotNull final Executor executor,
                                 @NotNull final ExecutionTarget target,
-                                @NotNull final RunnerAndConfigurationSettings configuration,
+                                @Nullable final RunnerAndConfigurationSettings configuration,
                                 @Nullable final ProcessHandler processHandler) {
     if (processHandler != null) {
       for (RunContentDescriptor descriptor : getContentManager().getAllDescriptors()) {
@@ -279,13 +279,18 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   public void restartRunProfile(@NotNull final Project project,
                                 @NotNull final Executor executor,
                                 @NotNull final ExecutionTarget target,
-                                @NotNull final RunnerAndConfigurationSettings configuration,
+                                @Nullable final RunnerAndConfigurationSettings configuration,
                                 @Nullable final RunContentDescriptor currentDescriptor) {
-    if (ProgramRunnerUtil.getRunner(executor.getId(), configuration) == null) {
+    if (configuration != null && ProgramRunnerUtil.getRunner(executor.getId(), configuration) == null) {
+      LOG.error("Cannot find runner for " + configuration.getName());
+      return;
+    }
+    if (configuration == null && (currentDescriptor == null || currentDescriptor.getRestarter() == null)) {
+      LOG.error("Nothing to restart");
       return;
     }
     final List<RunContentDescriptor> descriptorsToStop = new ArrayList<RunContentDescriptor>();
-    if (configuration.isSingleton()) {
+    if (configuration != null && configuration.isSingleton()) {
       descriptorsToStop.addAll(getRunningDescriptors(configuration));
     }
     else if (currentDescriptor != null) {
@@ -293,7 +298,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
     }
 
     if (!descriptorsToStop.isEmpty()) {
-      if ((descriptorsToStop.size() > 1 || currentDescriptor == null || descriptorsToStop.get(0) != currentDescriptor) &&
+      if (configuration != null && (descriptorsToStop.size() > 1 || currentDescriptor == null || descriptorsToStop.get(0) != currentDescriptor) &&
           !userApprovesStop(project, configuration.getName(), descriptorsToStop.size())) {
         return;
       }
@@ -302,7 +307,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
       }
     }
     else {
-      ProgramRunnerUtil.executeConfiguration(project, configuration, executor, target, currentDescriptor, true);
+      start(project, configuration, executor, target, currentDescriptor);
       return;
     }
 
@@ -316,12 +321,26 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
             return;
           }
         }
-        ProgramRunnerUtil.executeConfiguration(project, configuration, executor, target, currentDescriptor, true);
+        start(project, configuration, executor, target, currentDescriptor);
       }
     };
     awaitingTerminationAlarm.addRequest(runnable, 100);
   }
 
+  private static void start(@NotNull Project project,
+                            @Nullable RunnerAndConfigurationSettings configuration,
+                            @NotNull Executor executor,
+                            @NotNull ExecutionTarget target,
+                            @Nullable RunContentDescriptor descriptor) {
+    Runnable restarter = descriptor != null ? descriptor.getRestarter() : null;
+    if (configuration != null) {
+      ProgramRunnerUtil.executeConfiguration(project, configuration, executor, target, descriptor, true);
+    }
+    else if (restarter != null) {
+      restarter.run();
+    }
+  }
+
   private static boolean userApprovesStop(Project project, String configName, int instancesCount) {
     RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project);
     final RunManagerConfig config = runManager.getConfig();
@@ -376,7 +395,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   }
 
 
-  private void stop(RunContentDescriptor runContentDescriptor) {
+  private static void stop(RunContentDescriptor runContentDescriptor) {
     ProcessHandler processHandler = runContentDescriptor != null ? runContentDescriptor.getProcessHandler() : null;
     if (processHandler == null) {
       return;
diff --git a/platform/lang-impl/src/com/intellij/execution/runners/RestartAction.java b/platform/lang-impl/src/com/intellij/execution/runners/RestartAction.java
index a0605c6b8e21..03e302bbf4d0 100644
--- a/platform/lang-impl/src/com/intellij/execution/runners/RestartAction.java
+++ b/platform/lang-impl/src/com/intellij/execution/runners/RestartAction.java
@@ -108,31 +108,24 @@ public class RestartAction extends FakeRerunAction implements DumbAware, AnActio
 
   public void actionPerformed(final AnActionEvent e) {
     Project project = myEnvironment.getProject();
-    RunnerAndConfigurationSettings settings = myEnvironment.getRunnerAndConfigurationSettings();
     if (project == null)
       return;
-    if (settings != null) {
       if (myProcessHandler != null) {
         ExecutionManager.getInstance(project).restartRunProfile(project,
                                                                 myExecutor,
                                                                 myEnvironment.getExecutionTarget(),
-                                                                settings,
+                                                                myEnvironment.getRunnerAndConfigurationSettings(),
                                                                 myProcessHandler);
       }
       else {
         ExecutionManager.getInstance(project).restartRunProfile(project,
                                                                 myExecutor,
                                                                 myEnvironment.getExecutionTarget(),
-                                                                settings,
+                                                                myEnvironment.getRunnerAndConfigurationSettings(),
                                                                 myDescriptor);
       }
-    }
-    else {
-      restart();
-    }
   }
 
-  //Should be used by android framework only
   public void restart() {
     final Project project = PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myDescriptor.getComponent()));
     if (ExecutorRegistry.getInstance().isStarting(project, myExecutor.getId(), myRunner.getRunnerId())) {

From 0ed6496b3192fb317f63bc39a4b5e9e727ce91cd Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 16:44:04 +0100
Subject: [PATCH 141/354] TOO_EXPENSIVE_SIZE -> TOO_EXPENSIVE_HASH

---
 .../codeInspection/dataFlow/DataFlowRunner.java        | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
index 4328827ad07d..6a1ce9b2e82d 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/DataFlowRunner.java
@@ -46,7 +46,7 @@ import java.util.*;
 
 public class DataFlowRunner {
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInspection.dataFlow.DataFlowRunner");
-  private static final Key<Integer> TOO_EXPENSIVE_SIZE = Key.create("TOO_EXPENSIVE_SIZE");
+  private static final Key<Integer> TOO_EXPENSIVE_HASH = Key.create("TOO_EXPENSIVE_HASH");
   public static final long ourTimeLimit = 1000 * 1000 * 1000; //1 sec in nanoseconds
 
   private Instruction[] myInstructions;
@@ -110,8 +110,8 @@ public class DataFlowRunner {
         }
       }
 
-      Integer tooExpensiveSize = psiBlock.getUserData(TOO_EXPENSIVE_SIZE);
-      if (tooExpensiveSize != null && tooExpensiveSize == psiBlock.getText().hashCode()) {
+      Integer tooExpensiveHash = psiBlock.getUserData(TOO_EXPENSIVE_HASH);
+      if (tooExpensiveHash != null && tooExpensiveHash == psiBlock.getText().hashCode()) {
         LOG.debug("Too complex because hasn't changed since being too complex already");
         return RunnerResult.TOO_COMPLEX;
       }
@@ -128,7 +128,7 @@ public class DataFlowRunner {
       while (!queue.isEmpty()) {
         if (count % 50 == 0 && !unitTestMode && measurer.isTimeOver()) {
           LOG.debug("Too complex because the analysis took too long");
-          psiBlock.putUserData(TOO_EXPENSIVE_SIZE, psiBlock.getText().hashCode());
+          psiBlock.putUserData(TOO_EXPENSIVE_HASH, psiBlock.getText().hashCode());
           return RunnerResult.TOO_COMPLEX;
         }
         ProgressManager.checkCanceled();
@@ -166,7 +166,7 @@ public class DataFlowRunner {
         count++;
       }
 
-      psiBlock.putUserData(TOO_EXPENSIVE_SIZE, null);
+      psiBlock.putUserData(TOO_EXPENSIVE_HASH, null);
       LOG.debug("Analysis ok");
       return RunnerResult.OK;
     }

From 5d1ef88544554d948a95c3802ff14f48f19d8de7 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 16:58:49 +0100
Subject: [PATCH 142/354] formatter stuff is absolutely inappropriate in
 completion

---
 .../JavaMemberNameCompletionContributor.java  | 55 ++++++++-----------
 1 file changed, 22 insertions(+), 33 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java
index 4a1ac632a868..1a21b65af873 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaMemberNameCompletionContributor.java
@@ -24,7 +24,6 @@ import com.intellij.patterns.ElementPattern;
 import com.intellij.patterns.PsiJavaPatterns;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.psi.codeStyle.SuggestedNameInfo;
 import com.intellij.psi.codeStyle.VariableKind;
@@ -366,46 +365,36 @@ public class JavaMemberNameCompletionContributor extends CompletionContributor {
                                                     final boolean staticContext,
                                                     final PsiType varType,
                                                     final PsiElement element) {
-    class Change implements Runnable {
-      private String[] result;
+    final List<String> propertyHandlers = new ArrayList<String>();
 
-      @Override
-      public void run() {
-        final List<String> propertyHandlers = new ArrayList<String>();
-        final PsiField[] fields = psiClass.getFields();
+    for (final PsiField field : psiClass.getFields()) {
+      if (field == element) continue;
 
-        for (final PsiField field : fields) {
-          if (field == element) continue;
+      assert field.isValid() : "invalid field: " + field;
+      PsiType fieldType = field.getType();
+      assert fieldType.isValid() : "invalid field type: " + field + "; " + fieldType + " of " + fieldType.getClass();
 
-          assert field.isValid() : "invalid field: " + field;
-          PsiType fieldType = field.getType();
-          assert fieldType.isValid() : "invalid field type: " + field + "; " + fieldType + " of " + fieldType.getClass();
+      final PsiModifierList modifierList = field.getModifierList();
+      if (staticContext && (modifierList != null && !modifierList.hasModifierProperty(PsiModifier.STATIC))) continue;
 
-          final PsiModifierList modifierList = field.getModifierList();
-          if (staticContext && (modifierList != null && !modifierList.hasModifierProperty(PsiModifier.STATIC))) continue;
+      if (fieldType.equals(varType)) {
+        final String getterName = PropertyUtil.suggestGetterName(field.getProject(), field);
+        if ((psiClass.findMethodsByName(getterName, true).length == 0 ||
+             psiClass.findMethodBySignature(PropertyUtil.generateGetterPrototype(field), true) == null)) {
+          propertyHandlers.add(getterName);
+        }
+      }
 
-          if (fieldType.equals(varType)) {
-            final String getterName = PropertyUtil.suggestGetterName(field.getProject(), field);
-            if ((psiClass.findMethodsByName(getterName, true).length == 0 ||
-                 psiClass.findMethodBySignature(PropertyUtil.generateGetterPrototype(field), true) == null)) {
-              propertyHandlers.add(getterName);
-            }
-          }
-
-          if (PsiType.VOID.equals(varType)) {
-            final String setterName = PropertyUtil.suggestSetterName(field.getProject(), field);
-            if ((psiClass.findMethodsByName(setterName, true).length == 0 ||
-                 psiClass.findMethodBySignature(PropertyUtil.generateSetterPrototype(field), true) == null)) {
-              propertyHandlers.add(setterName);
-            }
-          }
+      if (PsiType.VOID.equals(varType)) {
+        final String setterName = PropertyUtil.suggestSetterName(field.getProject(), field);
+        if ((psiClass.findMethodsByName(setterName, true).length == 0 ||
+             psiClass.findMethodBySignature(PropertyUtil.generateSetterPrototype(field), true) == null)) {
+          propertyHandlers.add(setterName);
         }
-        result = ArrayUtil.toStringArray(propertyHandlers);
       }
     }
-    final Change result = new Change();
-    CodeStyleManager.getInstance(element.getProject()).performActionWithFormatterDisabled(result);
-    return result.result;
+
+    return ArrayUtil.toStringArray(propertyHandlers);
   }
 
   private static void addLookupItems(Set<LookupElement> lookupElements, @Nullable final SuggestedNameInfo callback, PrefixMatcher matcher, Project project, String... strings) {

From 7d92332730de9521b86f08850eb837e179a53110 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 17:06:54 +0100
Subject: [PATCH 143/354] check only for null range

---
 .../intellij/codeInsight/hint/ImplementationViewComponent.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java b/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
index 8a7bd9f7b796..efa6561c24a0 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/hint/ImplementationViewComponent.java
@@ -428,7 +428,7 @@ public class ImplementationViewComponent extends JPanel {
     final Document doc = PsiDocumentManager.getInstance(project).getDocument(psiFile);
     if (doc == null) return null;
 
-    if (elt.getText() == null || elt.getTextRange() == null) {
+    if (elt.getTextRange() == null) {
       return null;
     }
 

From 0e906a07c01b4b43a9a78b09dfa0e872e50d5836 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 17:30:16 +0100
Subject: [PATCH 144/354] fail on creating invalid substitutors (EA-44034)

---
 .../src/com/intellij/psi/impl/EmptySubstitutorImpl.java  | 5 +++++
 .../src/com/intellij/psi/impl/PsiSubstitutorImpl.java    | 9 ++++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/EmptySubstitutorImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/EmptySubstitutorImpl.java
index 04760c81e387..9a327a846a04 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/EmptySubstitutorImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/EmptySubstitutorImpl.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.psi.impl;
 
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 
@@ -25,6 +26,7 @@ import java.util.Map;
  *  @author dsl
  */
 public final class EmptySubstitutorImpl extends EmptySubstitutor {
+  private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.EmptySubstitutorImpl");
   @Override
   public PsiType substitute(@NotNull PsiTypeParameter typeParameter){
     return JavaPsiFacade.getInstance(typeParameter.getProject()).getElementFactory().createType(typeParameter);
@@ -42,6 +44,9 @@ public final class EmptySubstitutorImpl extends EmptySubstitutor {
 
   @Override
   public PsiSubstitutor put(PsiTypeParameter classParameter, PsiType mapping){
+    if (mapping != null && !mapping.isValid()) {
+      LOG.error("Invalid type in substitutor: " + mapping);
+    }
     return new PsiSubstitutorImpl(classParameter, mapping);
   }
 
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java
index 5697c55ab092..1fd39555af98 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiSubstitutorImpl.java
@@ -414,6 +414,9 @@ public class PsiSubstitutorImpl implements PsiSubstitutor {
   @Override
   public PsiSubstitutor put(@NotNull PsiTypeParameter typeParameter, PsiType mapping) {
     PsiSubstitutorImpl ret = clone();
+    if (mapping != null && !mapping.isValid()) {
+      LOG.error("Invalid type in substitutor: " + mapping);
+    }
     ret.mySubstitutionMap.put(typeParameter, mapping);
     return ret;
   }
@@ -425,7 +428,11 @@ public class PsiSubstitutorImpl implements PsiSubstitutor {
       PsiTypeParameter param = params[i];
       assert param != null;
       if (mappings != null && mappings.length > i) {
-        mySubstitutionMap.put(param, mappings[i]);
+        PsiType mapping = mappings[i];
+        mySubstitutionMap.put(param, mapping);
+        if (mapping != null && !mapping.isValid()) {
+          LOG.error("Invalid type in substitutor: " + mapping);
+        }
       }
       else {
         mySubstitutionMap.put(param, null);

From e7078f2498bcf2266707a5f625990884732c0478 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Mon, 25 Feb 2013 17:41:48 +0100
Subject: [PATCH 145/354] don't create class lookup element for noname classes
 (EA-41335)

---
 .../codeInsight/lookup/PsiTypeLookupItem.java | 37 ++++++++++---------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java b/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java
index cba613755b46..e93cd0d70cbc 100644
--- a/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java
+++ b/java/java-impl/src/com/intellij/codeInsight/lookup/PsiTypeLookupItem.java
@@ -28,6 +28,7 @@ import com.intellij.psi.impl.DebugUtil;
 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
 import com.intellij.psi.impl.source.PsiClassReferenceType;
 import com.intellij.psi.util.PsiUtil;
+import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -213,27 +214,29 @@ public class PsiTypeLookupItem extends LookupItem {
       final PsiClass psiClass = classResolveResult.getElement();
 
       if (psiClass != null) {
-        final PsiSubstitutor substitutor = classResolveResult.getSubstitutor();
+        String name = psiClass.getName();
+        if (name != null) {
+          final PsiSubstitutor substitutor = classResolveResult.getSubstitutor();
 
-        PsiClass resolved = JavaPsiFacade.getInstance(psiClass.getProject()).getResolveHelper().resolveReferencedClass(psiClass.getName(), context);
+          PsiClass resolved = JavaPsiFacade.getInstance(psiClass.getProject()).getResolveHelper().resolveReferencedClass(name, context);
 
-        Set<String> allStrings = new HashSet<String>();
-        String lookupString = psiClass.getName();
-        allStrings.add(lookupString);
-        if (!psiClass.getManager().areElementsEquivalent(resolved, psiClass) && !PsiUtil.isInnerClass(psiClass)) {
-          // inner class name should be shown qualified if its not accessible by single name
-          PsiClass aClass = psiClass.getContainingClass();
-          while (aClass != null && !PsiUtil.isInnerClass(aClass)) {
-            lookupString = aClass.getName() + '.' + lookupString;
-            allStrings.add(lookupString);
-            aClass = aClass.getContainingClass();
+          Set<String> allStrings = new HashSet<String>();
+          allStrings.add(name);
+          if (!psiClass.getManager().areElementsEquivalent(resolved, psiClass) && !PsiUtil.isInnerClass(psiClass)) {
+            // inner class name should be shown qualified if its not accessible by single name
+            PsiClass aClass = psiClass.getContainingClass();
+            while (aClass != null && !PsiUtil.isInnerClass(aClass)) {
+              name = aClass.getName() + '.' + name;
+              allStrings.add(name);
+              aClass = aClass.getContainingClass();
+            }
           }
-        }
 
-        PsiTypeLookupItem item = new PsiTypeLookupItem(psiClass, lookupString, diamond, bracketsCount, importFixer);
-        item.addLookupStrings(allStrings.toArray(new String[allStrings.size()]));
-        item.setAttribute(SUBSTITUTOR, substitutor);
-        return item;
+          PsiTypeLookupItem item = new PsiTypeLookupItem(psiClass, name, diamond, bracketsCount, importFixer);
+          item.addLookupStrings(ArrayUtil.toStringArray(allStrings));
+          item.setAttribute(SUBSTITUTOR, substitutor);
+          return item;
+        }
       }
 
     }

From 3e35b220b7f3731c31bea184642dea54e6056221 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Mon, 25 Feb 2013 21:05:35 +0400
Subject: [PATCH 146/354] IDEA-48177 Run tab of already terminated process is
 not occupied with new process, if current tab is busy

---
 .../execution/ui/RunContentManagerImpl.java   | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
index c044e5b8c97b..e64ab5d29bf6 100644
--- a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
@@ -406,18 +406,9 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
       if (attachedContent != null && attachedContent.isValid()) content = attachedContent;
     }
     //Stage three: choose the content with name we prefer
-    if (content == null && preferredName != null) {
+    if (content == null) {
       content = getContentFromManager(contentManager, preferredName, executionId);
     }
-    //Stage four: try to get current selected content
-    if (content == null) {
-      content = contentManager.getSelectedContent();
-      if (content != null && content.isPinned()) content = null;
-    }
-    //Stage five: content is still null and every "old good" content is acceptable
-    if (content == null) {
-      content = getContentFromManager(contentManager, null, executionId);
-    }
     if (content == null || !isTerminated(content) || (content.getExecutionId() == executionId && executionId != 0)) {
       return null;
     }
@@ -432,7 +423,11 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
 
   @Nullable
   private static Content getContentFromManager(ContentManager contentManager, @Nullable String preferredName, long executionId) {
-    Content[] contents = contentManager.getContents();
+    ArrayList<Content> contents = new ArrayList<Content>(Arrays.asList(contentManager.getContents()));
+    Content first = contentManager.getSelectedContent();
+    if (first != null && contents.remove(first)) {
+      contents.add(0, first);
+    }
     for (Content c : contents) {
       if (c == null || c.isPinned() || !isTerminated(c) || (c.getExecutionId() == executionId && executionId != 0))
         continue;
@@ -442,7 +437,7 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
         return c;
       }
     }
-    return null;
+    return preferredName != null ? getContentFromManager(contentManager, null, executionId) : null;
   }
 
   private ContentManager getContentManagerForRunner(final Executor executor) {

From 64e0e5063072fa4521087db61130658759ec6083 Mon Sep 17 00:00:00 2001
From: Fedor Korotkov <fedor.korotkov@jetbrains.com>
Date: Mon, 25 Feb 2013 21:05:49 +0400
Subject: [PATCH 147/354] Microdata: WEB-6805 HTML microdata: no completion if
 the element referenced via itemref has upper nesting level than the element
 with the itemscope attribute

---
 ...MicrodataAttributeDescriptorsProvider.java |  2 +-
 .../html/impl/util/MicrodataUtil.java         | 63 +++++++++----------
 .../html/MicrodataCompletionTest.java         | 25 ++++++++
 3 files changed, 57 insertions(+), 33 deletions(-)

diff --git a/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
index 319ae1a9d5b4..a652b4c9cc82 100644
--- a/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
+++ b/xml/impl/src/com/intellij/html/impl/MicrodataAttributeDescriptorsProvider.java
@@ -115,7 +115,7 @@ public class MicrodataAttributeDescriptorsProvider implements XmlAttributeDescri
 
     @Override
     public String[] getEnumeratedValues() {
-      final XmlTag scopeParent = findScopeTag(myContext.getParentTag());
+      final XmlTag scopeParent = findScopeTag(myContext);
       return scopeParent != null ? findProperties(scopeParent) : super.getEnumeratedValues();
     }
 
diff --git a/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
index 5467388e914a..78fb7255d147 100644
--- a/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
+++ b/xml/impl/src/com/intellij/html/impl/util/MicrodataUtil.java
@@ -22,7 +22,6 @@ import com.intellij.codeInsight.daemon.impl.quickfix.ManuallySetupExtResourceAct
 import com.intellij.codeInsight.daemon.impl.quickfix.QuickFixAction;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.text.StringUtil;
@@ -37,17 +36,14 @@ import com.intellij.psi.xml.XmlAttributeValue;
 import com.intellij.psi.xml.XmlFile;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.PairFunction;
-import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.text.StringTokenizer;
+import gnu.trove.THashMap;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * @author: Fedor.Korotkov
@@ -68,39 +64,39 @@ public class MicrodataUtil {
   }
 
   @Nullable
-  public static XmlTag findScopeTag(@Nullable XmlTag tag) {
+  public static XmlTag findScopeTag(@Nullable XmlTag context) {
+    Map<String, XmlTag> id2tag = findScopesWithItemRef(context != null ? context.getContainingFile() : null);
+    XmlTag tag = context;
     while (tag != null) {
-      if (tag.getAttribute(ITEM_SCOPE) != null) return tag;
-      XmlTag scopeTag = findInRefsById(tag);
-      if (scopeTag != null) return scopeTag;
+      if (tag != context && tag.getAttribute(ITEM_SCOPE) != null) return tag;
+      final String id = getStripedAttributeValue(tag, "id");
+      if (id != null && id2tag.containsKey(id)) return id2tag.get(id);
       tag = tag.getParentTag();
     }
     return null;
   }
 
-  @Nullable
-  private static XmlTag findInRefsById(XmlTag tag) {
-    XmlAttribute idAttr = tag.getAttribute("id");
-    final XmlAttributeValue idValue = idAttr != null ? idAttr.getValueElement() : null;
-    if (idValue == null) {
-      return null;
-    }
-    final String idToFind = StringUtil.stripQuotesAroundValue(idValue.getText());
-    XmlTag parentTag = tag.getParentTag();
-    while (parentTag != null) {
-      XmlTag scopeTag = ContainerUtil.find(parentTag.getSubTags(), new Condition<XmlTag>() {
-        @Override
-        public boolean value(XmlTag tag) {
-          String refValue = tag.getAttributeValue(ITEM_REF);
-          return refValue != null && refValue.contains(idToFind);
+  private static Map<String, XmlTag> findScopesWithItemRef(@Nullable PsiFile file) {
+    if (!(file instanceof XmlFile)) return Collections.emptyMap();
+    final Map<String, XmlTag> result = new THashMap<String, XmlTag>();
+    file.accept(new XmlRecursiveElementVisitor() {
+      @Override
+      public void visitXmlTag(final XmlTag tag) {
+        super.visitXmlTag(tag);
+        XmlAttribute refAttr = tag.getAttribute(ITEM_REF);
+        if (refAttr != null && tag.getAttribute(ITEM_SCOPE) != null) {
+          getReferencesForAttributeValue(refAttr.getValueElement(), new PairFunction<String, Integer, PsiReference>() {
+            @Nullable
+            @Override
+            public PsiReference fun(String t, Integer v) {
+              result.put(t, tag);
+              return null;
+            }
+          });
         }
-      });
-      if (scopeTag != null) {
-        return scopeTag;
       }
-      parentTag = parentTag.getParentTag();
-    }
-    return null;
+    });
+    return result;
   }
 
   public static List<String> extractProperties(PsiFile file, String type) {
@@ -151,8 +147,11 @@ public class MicrodataUtil {
     });
   }
 
-  public static PsiReference[] getReferencesForAttributeValue(XmlAttributeValue element,
+  public static PsiReference[] getReferencesForAttributeValue(@Nullable XmlAttributeValue element,
                                                               PairFunction<String, Integer, PsiReference> refFun) {
+    if (element == null) {
+      return PsiReference.EMPTY_ARRAY;
+    }
     String text = element.getText();
     String urls = StringUtil.stripQuotesAroundValue(text);
     StringTokenizer tokenizer = new StringTokenizer(urls);
diff --git a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
index d621b286d092..9a0c19ed5542 100644
--- a/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
+++ b/xml/tests/src/com/intellij/html/MicrodataCompletionTest.java
@@ -214,4 +214,29 @@ public class MicrodataCompletionTest extends CodeInsightFixtureTestCase {
                  "name", "nickname", "photo", "title", "role", "url", "affiliation", "friend", "acquaintance", "address"
     );
   }
+
+  public void testPropValueNestedScopesDifferentTrees() throws Throwable {
+    final VirtualFile personFile = myFixture.copyFileToProject("Person.html");
+    final VirtualFile addressFile = myFixture.copyFileToProject("Address.html");
+    ApplicationManager.getApplication().runWriteAction(new Runnable() {
+      @Override
+      public void run() {
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Person", personFile.getPath());
+        ExternalResourceManager.getInstance().addResource("http://data-vocabulary.org/Address", addressFile.getPath());
+      }
+    });
+    doTestInHtml("<div itemscope itemtype=\"http://data-vocabulary.org/Person\" >\n" +
+                 "    name is <span itemprop=\"name\">ann</span>\n" +
+                 "    role is <span itemprop=\"role\">smth</span>\n" +
+                 "   <span itemprop=\"address\" itemscope\n" +
+                 "         itemtype=\"http://data-vocabulary.org/Address\" itemref=\"qq\">\n" +
+                 "      <span itemprop=\"locality\">spb</span>\n" +
+                 "   </span>\n" +
+                 "</div>\n" +
+                 "<div>\n" +
+                 "    <span id=\"qq\" itemprop=\"<caret>\">russia</span>\n" +
+                 "</div>",
+                 "street-address", "locality", "region", "postal-code", "country-name"
+    );
+  }
 }

From 41c7532046b89fa6ef64038e89b008f133ee7c0a Mon Sep 17 00:00:00 2001
From: Alexander Kirillin <angus@jetbrains.com>
Date: Mon, 25 Feb 2013 20:44:27 +0400
Subject: [PATCH 148/354] OC-6080 Move Refactoring: Move Members/Declarations:
 "Choose Containing class" dialog probably should not suggest framework
 classes

---
 .../intellij/ide/util/TreeJavaClassChooserDialog.java    | 2 +-
 .../ide/util/AbstractTreeClassChooserDialog.java         | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/java/java-impl/src/com/intellij/ide/util/TreeJavaClassChooserDialog.java b/java/java-impl/src/com/intellij/ide/util/TreeJavaClassChooserDialog.java
index 98fc00ed91ee..994bddb9458c 100644
--- a/java/java-impl/src/com/intellij/ide/util/TreeJavaClassChooserDialog.java
+++ b/java/java-impl/src/com/intellij/ide/util/TreeJavaClassChooserDialog.java
@@ -60,7 +60,7 @@ public class TreeJavaClassChooserDialog extends AbstractTreeClassChooserDialog<P
                                     @Nullable ClassFilter classFilter,
                                     PsiClass baseClass,
                                     @Nullable PsiClass initialClass, boolean isShowMembers) {
-    super(title, project, scope, PsiClass.class, createFilter(classFilter), baseClass, initialClass, isShowMembers);
+    super(title, project, scope, PsiClass.class, createFilter(classFilter), baseClass, initialClass, isShowMembers, true);
   }
 
   @Override
diff --git a/platform/lang-impl/src/com/intellij/ide/util/AbstractTreeClassChooserDialog.java b/platform/lang-impl/src/com/intellij/ide/util/AbstractTreeClassChooserDialog.java
index 97a22e2ad7e1..58ede020d6c8 100644
--- a/platform/lang-impl/src/com/intellij/ide/util/AbstractTreeClassChooserDialog.java
+++ b/platform/lang-impl/src/com/intellij/ide/util/AbstractTreeClassChooserDialog.java
@@ -81,6 +81,7 @@ public abstract class AbstractTreeClassChooserDialog<T extends PsiNamedElement>
   @Nullable private final T myBaseClass;
   private T myInitialClass;
   private final boolean myIsShowMembers;
+  private final boolean myIsShowLibraryContents;
 
   public AbstractTreeClassChooserDialog(String title, Project project, final Class<T> elementClass) {
     this(title, project, elementClass, null);
@@ -96,7 +97,7 @@ public abstract class AbstractTreeClassChooserDialog<T extends PsiNamedElement>
                                         @NotNull Class<T> elementClass,
                                         @Nullable Filter<T> classFilter,
                                         @Nullable T initialClass) {
-    this(title, project, scope, elementClass, classFilter, null, initialClass, false);
+    this(title, project, scope, elementClass, classFilter, null, initialClass, false, true);
   }
 
   public AbstractTreeClassChooserDialog(String title,
@@ -106,7 +107,8 @@ public abstract class AbstractTreeClassChooserDialog<T extends PsiNamedElement>
                                         @Nullable Filter<T> classFilter,
                                         @Nullable T baseClass,
                                         @Nullable T initialClass,
-                                        boolean isShowMembers) {
+                                        boolean isShowMembers,
+                                        boolean isShowLibraryContents) {
     super(project, true);
     myScope = scope;
     myElementClass = elementClass;
@@ -114,6 +116,7 @@ public abstract class AbstractTreeClassChooserDialog<T extends PsiNamedElement>
     myBaseClass = baseClass;
     myInitialClass = initialClass;
     myIsShowMembers = isShowMembers;
+    myIsShowLibraryContents = isShowLibraryContents;
     setTitle(title);
     myProject = project;
     init();
@@ -161,7 +164,7 @@ public abstract class AbstractTreeClassChooserDialog<T extends PsiNamedElement>
 
       @Override
       public boolean isShowLibraryContents() {
-        return true;
+        return myIsShowLibraryContents;
       }
 
       @Override

From b562064e02e47c011c81494c6b30fcaa2a70ecd7 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 17:18:18 +0100
Subject: [PATCH 149/354] lambda: conditional inference updated

---
 .../source/resolve/GraphInferencePolicy.java  |  3 +-
 ...CandidateParameterTypeInferencePolicy.java |  7 ++--
 .../source/resolve/PsiResolveHelperImpl.java  |  4 +--
 .../ConditionalInferenceFromOppositePart.java | 36 +++++++++++++++++++
 .../daemon/lambda/LambdaHighlightingTest.java |  4 +++
 5 files changed, 47 insertions(+), 7 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ConditionalInferenceFromOppositePart.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
index a6593a730008..0b895d74dc16 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/GraphInferencePolicy.java
@@ -19,6 +19,7 @@ import com.intellij.psi.*;
 import com.intellij.psi.scope.MethodProcessorSetupFailedException;
 import com.intellij.psi.scope.processor.MethodCandidatesProcessor;
 import com.intellij.psi.scope.util.PsiScopesUtil;
+import com.intellij.psi.util.PsiUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -100,7 +101,7 @@ public class GraphInferencePolicy extends ProcessCandidateParameterTypeInference
 
   public static void forget(PsiElement parent) {
     if (parent instanceof PsiExpression) {
-      final PsiElement gParent = parent.getParent();
+      PsiElement gParent = PsiUtil.skipParenthesizedExprUp(parent.getParent());
       if (gParent instanceof PsiExpressionList) {
         final PsiElement ggParent = gParent.getParent();
         if (ggParent instanceof PsiCallExpression) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
index e9045a8c9c15..fae1b5252a07 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/ProcessCandidateParameterTypeInferencePolicy.java
@@ -43,12 +43,11 @@ public class ProcessCandidateParameterTypeInferencePolicy extends DefaultParamet
                                                                           PsiCallExpression contextCall,
                                                                           PsiTypeParameter typeParameter) {
     PsiExpression[] expressions = expressionList.getExpressions();
-    PsiElement parent = innerMethodCall.getParent();
-    while (parent instanceof PsiParenthesizedExpression) {
-      innerMethodCall = (PsiExpression)parent;
+    PsiElement parent = innerMethodCall;
+    while (parent.getParent() instanceof PsiParenthesizedExpression) {
       parent = parent.getParent();
     }
-    int i = ArrayUtil.find(expressions, innerMethodCall);
+    int i = ArrayUtil.find(expressions, parent);
     if (i < 0) return null;
     PsiMethod owner = (PsiMethod)typeParameter.getOwner();
     if (owner == null) return null;
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
index 6f0b5c6a4ec4..386acc2ec493 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
@@ -1202,7 +1202,7 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
       final PsiExpression elseExpression = ((PsiConditionalExpression)parent).getElseExpression();
       final PsiType[] paramTypes = {((PsiMethod)typeParameter.getOwner()).getReturnType()};
       if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(elseExpression)) && thenExpression != null) {
-        final PsiType thenType = ourGraphGuard.doPreventingRecursion(thenExpression, true, new Computable<PsiType>() {
+        final PsiType thenType = ourGraphGuard.doPreventingRecursion(parent, true, new Computable<PsiType>() {
           @Override
           public PsiType compute() {
             return thenExpression.getType();
@@ -1212,7 +1212,7 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
           pair = inferTypeForMethodTypeParameterInner(typeParameter, paramTypes, new PsiType[] {thenType}, substitutor, null, policy);
         }
       } else if (methodCall.equals(PsiUtil.skipParenthesizedExprDown(thenExpression)) && elseExpression != null) {
-        final PsiType elseType = ourGraphGuard.doPreventingRecursion(elseExpression, true, new Computable<PsiType>() {
+        final PsiType elseType = ourGraphGuard.doPreventingRecursion(parent, true, new Computable<PsiType>() {
           @Override
           public PsiType compute() {
             return elseExpression.getType(); 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ConditionalInferenceFromOppositePart.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ConditionalInferenceFromOppositePart.java
new file mode 100644
index 000000000000..be6dd455770a
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ConditionalInferenceFromOppositePart.java
@@ -0,0 +1,36 @@
+public class Main {
+
+    interface Function<T, U> {
+        T fun(U t);
+    }
+
+    interface Sortable<X> {
+        Sortable<X> sort(Comparator<X> c);
+    }
+
+    static class Inner {
+        String foo() { return ""; }
+    }
+
+    <T2, U2> Comparator<U2> comparing(Function<T2, U2> mapper) {  return null; }
+
+    void testAssignmentContext(Sortable<Inner> sortable, boolean cond) {
+        Comparator<Inner> comparing0 = comparing(Inner::foo);
+        Comparator<Inner> comparing = comparing((p) -> p.foo());
+        Sortable<Inner> p1 = sortable.sort(comparing);
+        Sortable<Inner> p2 = sortable.sort(comparing(x->x.foo()));
+        Sortable<Inner> p3 = sortable.sort(cond ? comparing(Inner::foo) : comparing(x -> x.foo()));
+        Sortable<Inner> p4 =  sortable.sort((cond ? comparing(Inner::foo)  : comparing(x -> x.foo())));
+    }
+
+    void testMethodContext(Sortable<Inner> list, boolean cond) {
+        testMethodContext(list.sort(comparing(Inner::foo)), true);
+        testMethodContext(list.sort(comparing(x->x.foo())), true);
+        testMethodContext(list.sort(cond ? comparing(Inner::foo) : comparing(x -> x.foo())), true);
+        testMethodContext(list.sort((cond ? comparing(Inner::foo) : comparing(x -> x.foo()))), true);
+    }
+
+    interface Comparator<T> {
+        int compare(T o1, T o2);
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 53fa466743e8..0ecff16b3a0e 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -228,6 +228,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testConditionalInferenceFromOppositePart() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From 33a583584b46d0dafc2df7f65f9efe248cc5eb7e Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 18:41:22 +0100
Subject: [PATCH 150/354] do not apply substitutor twice (IDEA-101752)

---
 .../psi/HierarchicalMethodSignature.java      | 11 +++++++++-
 .../interfaceMethods/CyclicSubstitutor.java   | 22 +++++++++++++++++++
 .../Interface8MethodsHighlightingTest.java    |  1 +
 3 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/CyclicSubstitutor.java

diff --git a/java/java-psi-api/src/com/intellij/psi/HierarchicalMethodSignature.java b/java/java-psi-api/src/com/intellij/psi/HierarchicalMethodSignature.java
index 3c920d38a5e6..8de679aae04a 100644
--- a/java/java-psi-api/src/com/intellij/psi/HierarchicalMethodSignature.java
+++ b/java/java-psi-api/src/com/intellij/psi/HierarchicalMethodSignature.java
@@ -29,9 +29,18 @@ import java.util.List;
 public abstract class HierarchicalMethodSignature extends MethodSignatureBackedByPsiMethod {
   public HierarchicalMethodSignature(@NotNull MethodSignatureBackedByPsiMethod signature) {
     super(signature.getMethod(), signature.getSubstitutor(), signature.isRaw(), 
-          signature.getParameterTypes(), signature.getTypeParameters());
+          getParameterTypes(signature.getMethod()), signature.getTypeParameters());
   }
 
+  private static PsiType[] getParameterTypes(PsiMethod method) {
+    final PsiParameter[] parameters = method.getParameterList().getParameters();
+    final PsiType[] paramTypes = new PsiType[parameters.length];
+    for (int i = 0; i < paramTypes.length; i++) {
+      paramTypes[i] = parameters[i].getType();
+    }
+    return paramTypes;
+  }
+  
   /**
    * Returns the list of super method signatures for the specified signature.
    *
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/CyclicSubstitutor.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/CyclicSubstitutor.java
new file mode 100644
index 000000000000..80d0e5e96b53
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/CyclicSubstitutor.java
@@ -0,0 +1,22 @@
+public interface Iso<T, R> {
+    T deply(R r);
+
+    default Iso<R, T> inverse() {
+        final Iso<T, R> z = this;
+        return new Iso<R, T>() {
+            @Override
+            public R deply(T t) {
+                throw null;
+            }
+        };
+    }
+
+   static <T, R> Iso<R, T> inverse(Iso<T, R> z) {
+        return new Iso<R, T>() {
+            @Override
+            public R deply(T t) {
+                throw null;
+            }
+        };
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
index 4562a63e62d0..1b158ef45779 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
@@ -29,6 +29,7 @@ public class Interface8MethodsHighlightingTest extends LightDaemonAnalyzerTestCa
   public void testExtensionMethods() { doTest(false, false); }
   public void testInheritDefaultMethodInInterface() { doTest(false, false); }
   public void testStaticMethodsInFunctionalInterface() { doTest(false, false); }
+  public void testCyclicSubstitutor() { doTest(false, false); }
 
   public void testExtensionMethodSyntax() {
     enableInspectionTools(DeprecatedDefenderSyntaxInspection.class);

From 413e0c427e3921db6586224c1488c153633394b0 Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Mon, 25 Feb 2013 21:49:04 +0400
Subject: [PATCH 151/354] IDEA-101395 Good code is red: JavaScript language
 injection

---
 .../src/META-INF/intellilang-java-support.xml |  2 ++
 .../inject/CustomErrorElementFilter.java      | 26 +++++++++++++++++--
 .../intelliLang/inject/InjectorUtils.java     |  1 +
 3 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/plugins/IntelliLang/src/META-INF/intellilang-java-support.xml b/plugins/IntelliLang/src/META-INF/intellilang-java-support.xml
index cef677728345..fb438cc026b1 100644
--- a/plugins/IntelliLang/src/META-INF/intellilang-java-support.xml
+++ b/plugins/IntelliLang/src/META-INF/intellilang-java-support.xml
@@ -26,6 +26,8 @@
     <concatenationAwareInjector implementation="org.intellij.plugins.intelliLang.inject.java.ConcatenationInjector"/>
 
     <psi.referenceContributor implementation="org.intellij.plugins.intelliLang.inject.java.LanguageReferenceProvider"/>
+
+    <daemon.highlightInfoFilter implementation="org.intellij.plugins.intelliLang.inject.CustomErrorElementFilter"/>
   </extensions>
 
   <extensions defaultExtensionNs="org.intellij.intelliLang">
diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
index 367935d5b35d..b54d59f90b07 100644
--- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
+++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
@@ -15,20 +15,42 @@
  */
 package org.intellij.plugins.intelliLang.inject;
 
+import com.intellij.codeInsight.daemon.impl.HighlightInfo;
+import com.intellij.codeInsight.daemon.impl.HighlightInfoFilter;
 import com.intellij.codeInsight.highlighting.HighlightErrorFilter;
+import com.intellij.lang.annotation.HighlightSeverity;
+import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiErrorElement;
+import com.intellij.psi.PsiFile;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * @author Gregory.Shrago
  */
-public class CustomErrorElementFilter extends HighlightErrorFilter {
+public class CustomErrorElementFilter extends HighlightErrorFilter implements HighlightInfoFilter {
   public boolean shouldHighlightErrorElement(@NotNull final PsiErrorElement element) {
     return !value(element);
   }
 
   public static boolean value(final PsiErrorElement psiErrorElement) {
-    return Boolean.TRUE.equals(psiErrorElement.getContainingFile().getUserData(InjectedLanguageUtil.FRANKENSTEIN_INJECTION));
+    return isFrankenstein(psiErrorElement.getContainingFile());
+  }
+
+  @Override
+  public boolean accept(@NotNull HighlightInfo highlightInfo, @Nullable PsiFile file) {
+    if (highlightInfo.getSeverity() != HighlightSeverity.WARNING &&
+        highlightInfo.getSeverity() != HighlightSeverity.WEAK_WARNING) return true;
+    if (!isFrankenstein(file)) return true;
+    int start = highlightInfo.getStartOffset();
+    int end = highlightInfo.getEndOffset();
+    // the bad news are: offsets may be in host file or in injected file
+    String text = (end < file.getTextLength() ? file.getText() : file.getContext().getContainingFile().getText()).substring(start, end);
+    return !"missingValue".equals(text);
+  }
+
+  private static boolean isFrankenstein(PsiFile file) {
+    return file != null && Boolean.TRUE.equals(file.getUserData(InjectedLanguageUtil.FRANKENSTEIN_INJECTION));
   }
 }
diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/InjectorUtils.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/InjectorUtils.java
index 9b001aac48b7..364f241d253d 100644
--- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/InjectorUtils.java
+++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/InjectorUtils.java
@@ -223,6 +223,7 @@ public class InjectorUtils {
     String prefix = ObjectUtils.notNull(map.get("prefix"), "");
     String suffix = ObjectUtils.notNull(map.get("suffix"), "");
     BaseInjection injection = new BaseInjection(supportId);
+    injection.setDisplayName(text);
     injection.setInjectedLanguageId(languageId);
     injection.setPrefix(prefix);
     injection.setSuffix(suffix);

From 90f844bc1606f967001353f093a63ee1b92d12b6 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 19:31:43 +0100
Subject: [PATCH 152/354] optimize imports: accept the first supported importer

---
 .../com/intellij/lang/LanguageImportStatements.java    | 10 +++++++---
 platform/platform-resources/src/META-INF/XmlPlugin.xml |  1 -
 plugins/javaFX/src/META-INF/common-javaFX-plugin.xml   |  2 +-
 .../com/intellij/refactoring/XmlImportOptimizer.java   | 10 +---------
 4 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/lang/LanguageImportStatements.java b/platform/lang-api/src/com/intellij/lang/LanguageImportStatements.java
index 7154680a46ab..08af0d511afa 100644
--- a/platform/lang-api/src/com/intellij/lang/LanguageImportStatements.java
+++ b/platform/lang-api/src/com/intellij/lang/LanguageImportStatements.java
@@ -22,6 +22,7 @@ package com.intellij.lang;
 import com.intellij.psi.PsiFile;
 
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 public class LanguageImportStatements extends LanguageExtension<ImportOptimizer> {
@@ -34,9 +35,12 @@ public class LanguageImportStatements extends LanguageExtension<ImportOptimizer>
   public Set<ImportOptimizer> forFile(PsiFile file) {
     Set<ImportOptimizer> optimizers = new HashSet<ImportOptimizer>();
     for (PsiFile psiFile : file.getViewProvider().getAllFiles()) {
-      ImportOptimizer optimizer = forLanguage(psiFile.getLanguage());
-      if (optimizer != null && optimizer.supports(psiFile)) {
-        optimizers.add(optimizer);
+      List<ImportOptimizer> langOptimizers = allForLanguage(psiFile.getLanguage());
+      for (ImportOptimizer optimizer : langOptimizers) {
+        if (optimizer != null && optimizer.supports(psiFile)) {
+          optimizers.add(optimizer);
+          break;
+        }
       }
     }
     return optimizers;
diff --git a/platform/platform-resources/src/META-INF/XmlPlugin.xml b/platform/platform-resources/src/META-INF/XmlPlugin.xml
index 9aeae4eb1c56..e35ba77863cf 100644
--- a/platform/platform-resources/src/META-INF/XmlPlugin.xml
+++ b/platform/platform-resources/src/META-INF/XmlPlugin.xml
@@ -74,7 +74,6 @@
                     beanClass="com.intellij.lang.LanguageExtensionPoint">
       <with attribute="implementationClass" implements="com.intellij.lang.HtmlInlineScriptTokenTypesProvider"/>
     </extensionPoint>
-    <extensionPoint name="xml.importOptimizer" interface="com.intellij.lang.ImportOptimizer"/>
   </extensionPoints>
 
   <project-components>
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index c1e8699fea9b..4ddebeb1b51d 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -24,7 +24,7 @@
       <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxCollapseSubTagToAttributeIntention</className>
       <category>JavaFX</category>
     </intentionAction>
-    <xml.importOptimizer implementation="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer"/>
+    <lang.importOptimizer language="XML" implementationClass="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer" order="before XML"/>
     <psi.referenceContributor implementation="org.jetbrains.plugins.javaFX.fxml.refs.JavaFxReferencesContributor"/>
   </extensions>
 
diff --git a/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java b/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
index d27dc2bb95b5..fe78e55df189 100644
--- a/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
+++ b/xml/impl/src/com/intellij/refactoring/XmlImportOptimizer.java
@@ -21,8 +21,6 @@ import com.intellij.codeInspection.ProblemDescriptor;
 import com.intellij.codeInspection.ProblemsHolder;
 import com.intellij.codeInspection.QuickFix;
 import com.intellij.lang.ImportOptimizer;
-import com.intellij.openapi.extensions.ExtensionPointName;
-import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Condition;
 import com.intellij.psi.*;
@@ -42,8 +40,7 @@ import java.util.Map;
  *         Date: 11/7/11
  */
 public class XmlImportOptimizer implements ImportOptimizer {
-  public static final ExtensionPointName<ImportOptimizer> EP_NAME = ExtensionPointName.create("com.intellij.xml.importOptimizer");
-
+  
   private final XmlUnusedNamespaceInspection myInspection = new XmlUnusedNamespaceInspection();
   private final Condition<ProblemDescriptor> myCondition = new Condition<ProblemDescriptor>() {
     @Override
@@ -62,11 +59,6 @@ public class XmlImportOptimizer implements ImportOptimizer {
   @NotNull
   @Override
   public Runnable processFile(final PsiFile file) {
-    for (ImportOptimizer optimizer : Extensions.getExtensions(EP_NAME)) {
-      if (optimizer.supports(file)) {
-        return optimizer.processFile(file);
-      }
-    }
     return new Runnable() {
       @Override
       public void run() {

From cb89ada4c124b27dea3c8bf4681932e7d3597ac0 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Mon, 25 Feb 2013 23:09:54 +0400
Subject: [PATCH 153/354] IDEA-101757 Copy status message to clipboard

---
 .../openapi/wm/impl/status/StatusPanel.java   | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
index da086cb56d32..d33d3d0c84c2 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
@@ -15,12 +15,18 @@
  */
 package com.intellij.openapi.wm.impl.status;
 
+import com.intellij.ide.ClipboardSynchronizer;
 import com.intellij.notification.EventLog;
 import com.intellij.notification.Notification;
+import com.intellij.openapi.actionSystem.ActionManager;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.IdeActions;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.ui.JBMenuItem;
+import com.intellij.openapi.ui.JBPopupMenu;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.Trinity;
 import com.intellij.openapi.util.text.StringUtil;
@@ -35,6 +41,8 @@ import org.jetbrains.annotations.Nullable;
 import javax.swing.*;
 import javax.swing.border.EmptyBorder;
 import java.awt.*;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.ActionEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 
@@ -48,6 +56,7 @@ class StatusPanel extends JPanel {
   private boolean myDirty;
   private boolean myAfterClick;
   private Alarm myLogAlarm;
+  private final Action myCopyAction;
   private final TextPanel myTextPanel = new TextPanel() {
     @Override
     protected String getTextForPreferredSize() {
@@ -101,6 +110,7 @@ class StatusPanel extends JPanel {
         return true;
       }
     }.installOn(myTextPanel);
+    myCopyAction = createCopyAction();
 
     myTextPanel.addMouseListener(new MouseAdapter() {
       @Override
@@ -112,6 +122,15 @@ class StatusPanel extends JPanel {
           myTextPanel.setCursor(Cursor.getDefaultCursor());
         }
       }
+
+      @Override
+      public void mouseReleased(MouseEvent e) {
+        if (myCopyAction != null && e.isPopupTrigger()) {
+          JBPopupMenu menu = new JBPopupMenu();
+          menu.add(new JBMenuItem(myCopyAction));
+          menu.show(myTextPanel, e.getX(), e.getY());
+        }
+      }
     });
 
     add(myTextPanel, BorderLayout.WEST);
@@ -124,6 +143,24 @@ class StatusPanel extends JPanel {
 
   }
 
+  private Action createCopyAction() {
+    ActionManager actionManager = ActionManager.getInstance();
+    AnAction action = actionManager.getAction(IdeActions.ACTION_COPY);
+    return new AbstractAction(action.getTemplatePresentation().getText(), action.getTemplatePresentation().getIcon()) {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        StringSelection content = new StringSelection(getText());
+        ClipboardSynchronizer.getInstance().setContent(content, content);
+      }
+
+      @Override
+      public boolean isEnabled() {
+        return !getText().isEmpty();
+      }
+    };
+  }
+
+
   @Nullable
   private Project getActiveProject() {
     // a better way of finding a project would be great

From ff81527f69ee75dd1332748a686741c6713fd61c Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Mon, 25 Feb 2013 23:12:06 +0400
Subject: [PATCH 154/354] IDEA-101757 Copy status message to clipboard

---
 .../src/com/intellij/openapi/wm/impl/status/StatusPanel.java    | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
index d33d3d0c84c2..a1deb69473a8 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/StatusPanel.java
@@ -145,7 +145,9 @@ class StatusPanel extends JPanel {
 
   private Action createCopyAction() {
     ActionManager actionManager = ActionManager.getInstance();
+    if (actionManager == null) return null;
     AnAction action = actionManager.getAction(IdeActions.ACTION_COPY);
+    if (action == null) return null;
     return new AbstractAction(action.getTemplatePresentation().getText(), action.getTemplatePresentation().getIcon()) {
       @Override
       public void actionPerformed(ActionEvent e) {

From a75d739fe5f50727b9273029eb8aa4a5e86240b7 Mon Sep 17 00:00:00 2001
From: Kirill Safonov <kirill.safonov@jetbrains.com>
Date: Tue, 26 Feb 2013 00:29:18 +0400
Subject: [PATCH 155/354] branch 127

---
 build.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.txt b/build.txt
index 529199426bcb..3e64855acd9f 100644
--- a/build.txt
+++ b/build.txt
@@ -1 +1 @@
-126.SNAPSHOT
+128.SNAPSHOT

From 0ba4d72ac5ae6a58bf67a7b7f12eff84f9474461 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 19:49:32 +0100
Subject: [PATCH 156/354] javafx: support new
 FXMLLoader(getClass().getResource("*.fxml")); format

---
 .../fxml/refs/JavaFxReferencesContributor.java     | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
index ab1cfcb22880..059533aefee4 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxReferencesContributor.java
@@ -45,9 +45,9 @@ public class JavaFxReferencesContributor extends PsiReferenceContributor {
         final PsiLiteralExpression literalExpression = (PsiLiteralExpression)context;
         PsiMethodCallExpression callExpression = PsiTreeUtil.getParentOfType(literalExpression, PsiMethodCallExpression.class);
         if (callExpression != null && "getResource".equals(callExpression.getMethodExpression().getReferenceName())) {
-          final PsiMethodCallExpression superCall = PsiTreeUtil.getParentOfType(callExpression, PsiMethodCallExpression.class, true);
-          if (superCall != null) {
-            final PsiReferenceExpression methodExpression = superCall.getMethodExpression();
+          final PsiCallExpression superCall = PsiTreeUtil.getParentOfType(callExpression, PsiCallExpression.class, true);
+          if (superCall instanceof PsiMethodCallExpression) {
+            final PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)superCall).getMethodExpression();
             if ("load".equals(methodExpression.getReferenceName())) {
               final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
               PsiClass psiClass = null;
@@ -63,6 +63,14 @@ public class JavaFxReferencesContributor extends PsiReferenceContributor {
                 return true;
               }
             }
+          } else if (superCall instanceof PsiNewExpression) {
+            final PsiJavaCodeReferenceElement reference = ((PsiNewExpression)superCall).getClassOrAnonymousClassReference();
+            if (reference != null) {
+              final PsiElement resolve = reference.resolve();
+              if (resolve instanceof PsiClass && JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER.equals(((PsiClass)resolve).getQualifiedName())) {
+                return true;
+              }
+            }
           }
         }
         return false;

From 216a838c59e1e1d35f977450ea93150c9c4b0736 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 20:31:53 +0100
Subject: [PATCH 157/354] javafx: do not search for controller without
 necessity

---
 .../descriptors/JavaFxPropertyAttributeDescriptor.java   | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyAttributeDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyAttributeDescriptor.java
index 07d897054b9d..2e3180da7b53 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyAttributeDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyAttributeDescriptor.java
@@ -1,7 +1,9 @@
 package org.jetbrains.plugins.javaFX.fxml.descriptors;
 
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.*;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiEnumConstant;
+import com.intellij.psi.PsiField;
 import com.intellij.psi.xml.XmlAttribute;
 import com.intellij.psi.xml.XmlAttributeValue;
 import com.intellij.psi.xml.XmlElement;
@@ -104,9 +106,8 @@ public class JavaFxPropertyAttributeDescriptor implements XmlAttributeDescriptor
       final XmlAttributeValue xmlAttributeValue = (XmlAttributeValue)context;
       final PsiElement parent = xmlAttributeValue.getParent();
       if (parent instanceof XmlAttribute && JavaFxPsiUtil.checkIfAttributeHandler((XmlAttribute)parent)) {
-        final PsiClass controllerClass = JavaFxPsiUtil.getControllerClass(context.getContainingFile());
         if (value.startsWith("#")) {
-          if (controllerClass == null) {
+          if (JavaFxPsiUtil.getControllerClass(context.getContainingFile()) == null) {
             return "No controller specified for top level element";
           }
         }

From 786f4a394805c84f47730f19224009d578201ed7 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Mon, 25 Feb 2013 21:52:28 +0100
Subject: [PATCH 158/354] javafx: support injected through setController
 controllers (IDEA-101736)

---
 .../plugins/javaFX/fxml/JavaFxPsiUtil.java    | 104 +++++++++++++++++-
 1 file changed, 102 insertions(+), 2 deletions(-)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
index ed042024c606..7ff8934ef9bb 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
@@ -19,12 +19,16 @@ import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.lang.ASTNode;
 import com.intellij.lang.xml.XMLLanguage;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Key;
+import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
 import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.*;
 import com.intellij.psi.xml.*;
+import com.intellij.util.Processor;
 import com.intellij.xml.XmlElementDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -198,9 +202,11 @@ public class JavaFxPsiUtil {
     return null;
   }
   
-  public static PsiClass getControllerClass(PsiFile containingFile) {
+  private static final Key<CachedValue<PsiClass>> INJECTED_CONTROLLER = Key.create("javafx.injected.controller");
+  public static PsiClass getControllerClass(final PsiFile containingFile) {
     if (containingFile instanceof XmlFile) {
       final XmlTag rootTag = ((XmlFile)containingFile).getRootTag();
+      final Project project = containingFile.getProject();
       if (rootTag != null) {
         XmlAttribute attribute = rootTag.getAttribute(FxmlConstants.FX_CONTROLLER);
         if (attribute == null && FxmlConstants.FX_ROOT.equals(rootTag.getName())) {
@@ -209,10 +215,13 @@ public class JavaFxPsiUtil {
         if (attribute != null) {
           final String attributeValue = attribute.getValue();
           if (!StringUtil.isEmptyOrSpaces(attributeValue)) {
-            return  JavaPsiFacade.getInstance(containingFile.getProject()).findClass(attributeValue, containingFile.getResolveScope());
+            return  JavaPsiFacade.getInstance(project).findClass(attributeValue, containingFile.getResolveScope());
           }
         }
       }
+      CachedValuesManager manager = CachedValuesManager.getManager(containingFile.getProject());
+      return manager.getCachedValue(containingFile, INJECTED_CONTROLLER,
+                                    new JavaFxControllerCachedValueProvider(containingFile.getProject(), containingFile), true);
     }
     return null;
   }
@@ -358,4 +367,95 @@ public class JavaFxPsiUtil {
     }
     return null;
   }
+
+  private static class JavaFxControllerCachedValueProvider implements CachedValueProvider<PsiClass> {
+    private final Project myProject;
+    private final PsiFile myContainingFile;
+
+    public JavaFxControllerCachedValueProvider(Project project, PsiFile containingFile) {
+      myProject = project;
+      myContainingFile = containingFile;
+    }
+
+    @Nullable
+    @Override
+    public Result<PsiClass> compute() {
+      final Ref<PsiClass> injectedController = new Ref<PsiClass>();
+      final Ref<PsiFile> dep = new Ref<PsiFile>();
+      final PsiClass fxmlLoader =
+        JavaPsiFacade.getInstance(myProject).findClass(JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER, GlobalSearchScope.allScope(myProject));
+      if (fxmlLoader != null) {
+        final PsiMethod[] injectControllerMethods = fxmlLoader.findMethodsByName("setController", false);
+        if (injectControllerMethods.length == 1) {
+          final JavaFxRetrieveControllerProcessor processor = new JavaFxRetrieveControllerProcessor() {
+            @Override
+            protected boolean isResolveToSetter(PsiMethodCallExpression methodCallExpression) {
+              return methodCallExpression.resolveMethod() == injectControllerMethods[0];
+            }
+          };
+          ReferencesSearch.search(myContainingFile).forEach(new Processor<PsiReference>() {
+            @Override
+            public boolean process(PsiReference reference) {
+              final PsiElement element = reference.getElement();
+              if (element instanceof PsiLiteralExpression) {
+                final PsiNewExpression expression = PsiTreeUtil.getParentOfType(element, PsiNewExpression.class);
+                if (expression != null) {
+                  final PsiType type = expression.getType();
+                  if (type != null && type.equalsToText(JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER)) {
+                    final PsiElement parent = expression.getParent();
+                    if (parent instanceof PsiVariable) {
+                      ReferencesSearch.search(parent).forEach(processor);
+                      final PsiClass controller = processor.getInjectedController();
+                      if (controller != null) {
+                        injectedController.set(controller);
+                        dep.set(processor.getContainingFile());
+                        return false;
+                      }
+                    }
+                  }
+                }
+              }
+              return true;
+            }
+          });
+        }
+      }
+      return new Result<PsiClass>(injectedController.get(), dep.get() != null ? dep.get() : PsiModificationTracker.MODIFICATION_COUNT);
+    }
+
+    private static abstract class JavaFxRetrieveControllerProcessor implements Processor<PsiReference> {
+      private final Ref<PsiClass> myInjectedController = new Ref<PsiClass>();
+      private final Ref<PsiFile> myContainingFile = new Ref<PsiFile>();
+
+      protected abstract boolean isResolveToSetter(PsiMethodCallExpression methodCallExpression);
+
+      @Override
+      public boolean process(PsiReference reference) {
+        final PsiElement element = reference.getElement();
+        if (element instanceof PsiReferenceExpression) { 
+          final PsiMethodCallExpression methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
+          if (methodCallExpression != null && isResolveToSetter(methodCallExpression)) {
+            final PsiExpression[] expressions = methodCallExpression.getArgumentList().getExpressions();
+            if (expressions.length > 0) {
+              final PsiClass psiClass = PsiUtil.resolveClassInType(expressions[0].getType());
+              if (psiClass != null) {
+                myInjectedController.set(psiClass);
+                myContainingFile.set(methodCallExpression.getContainingFile());
+                return false;
+              }
+            }
+          }
+        }
+        return true;
+      }
+
+      private PsiClass getInjectedController() {
+        return myInjectedController.get();
+      }
+
+      private PsiFile getContainingFile() {
+        return myContainingFile.get();
+      }
+    }
+  }
 }

From e9f84b83d289e93ee8c9d7b88e39642a9c9f8249 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Mon, 25 Feb 2013 21:52:04 +0100
Subject: [PATCH 159/354] Strip annotations from package and import stubs

---
 .../intellij/slicer/SliceLeafAnalyzer.java    |  8 +-
 .../src/com/intellij/psi/util/PsiUtil.java    | 15 ++--
 .../stubs/JavaImportStatementElementType.java | 14 ++-
 .../psi/impl/source/JavaLightStubBuilder.java |  5 +-
 .../PsiJavaCodeReferenceElementImpl.java      |  2 +-
 .../psi/impl/source/tree/SourceUtil.java      | 58 ++++++++++---
 .../tree/java/PsiPackageStatementImpl.java    |  5 +-
 .../tree/java/PsiReferenceExpressionImpl.java |  2 +-
 .../com/intellij/psi/JavaStubBuilderTest.java | 85 ++++++++++++++++++-
 .../psi/impl/source/tree/AstBufferUtil.java   | 13 ++-
 .../psi/impl/source/tree/LightTreeUtil.java   |  4 +-
 11 files changed, 165 insertions(+), 46 deletions(-)

diff --git a/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java b/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java
index 31e3fe43a562..eccaa6505f2e 100644
--- a/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java
+++ b/java/java-impl/src/com/intellij/slicer/SliceLeafAnalyzer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -29,7 +29,7 @@ import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiJavaReference;
 import com.intellij.psi.PsiNamedElement;
-import com.intellij.psi.impl.source.tree.SourceUtil;
+import com.intellij.psi.impl.source.tree.AstBufferUtil;
 import com.intellij.util.NullableFunction;
 import com.intellij.util.PairProcessor;
 import com.intellij.util.WalkingState;
@@ -60,8 +60,8 @@ public class SliceLeafAnalyzer {
               elementToCompare = resolved;
             }
           }
-          return elementToCompare instanceof PsiNamedElement ?
-                 ((PsiNamedElement)elementToCompare).getName() : SourceUtil.getTextSkipWhiteSpaceAndComments(elementToCompare.getNode());
+          return elementToCompare instanceof PsiNamedElement ? ((PsiNamedElement)elementToCompare).getName()
+                                                             : AstBufferUtil.getTextSkippingWhitespaceComments(elementToCompare.getNode());
         }
       });
       return Comparing.hashcode(text);
diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
index 3494b083efbe..bba6f97400b8 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,6 +32,7 @@ import com.intellij.psi.meta.PsiMetaData;
 import com.intellij.psi.meta.PsiMetaOwner;
 import com.intellij.psi.search.ProjectScope;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.EmptyIterable;
@@ -473,7 +474,7 @@ public final class PsiUtil extends PsiUtilCore {
       PsiType argType = args[args.length - 1];
       if (argType == null) return ApplicabilityLevel.NOT_APPLICABLE;
       if (TypeConversionUtil.isAssignable(parmType, argType)) return ApplicabilityLevel.FIXED_ARITY;
-      
+
       if (isRaw) {
         final PsiType erasedParamType = TypeConversionUtil.erasure(parmType);
         final PsiType erasedArgType = TypeConversionUtil.erasure(argType);
@@ -550,7 +551,7 @@ public final class PsiUtil extends PsiUtilCore {
     if (typeParameters1.length != typeParameters2.length) return false;
     for (int i = 0; i < typeParameters1.length; i++) {
       final PsiType substituted2 = s2.substitute(typeParameters2[i]);
-      if (!Comparing.equal(s1.substituteWithBoundsPromotion(typeParameters1[i]), substituted2) && 
+      if (!Comparing.equal(s1.substituteWithBoundsPromotion(typeParameters1[i]), substituted2) &&
           !Comparing.equal(s1.substitute(typeParameters1[i]), substituted2)) return false;
     }
     if (aClass.hasModifierProperty(PsiModifier.STATIC)) return true;
@@ -858,7 +859,7 @@ public final class PsiUtil extends PsiUtilCore {
   public static boolean hasDefaultConstructor(@NotNull PsiClass clazz) {
     return hasDefaultConstructor(clazz, false);
   }
-  
+
   public static boolean hasDefaultConstructor(@NotNull PsiClass clazz, boolean allowProtected) {
     return hasDefaultConstructor(clazz, allowProtected, true);
   }
@@ -949,10 +950,14 @@ public final class PsiUtil extends PsiUtilCore {
     return parent instanceof PsiIfStatement && element == ((PsiIfStatement)parent).getElseBranch();
   }
 
-  public static boolean isJavaToken(@Nullable final PsiElement element, final IElementType type) {
+  public static boolean isJavaToken(@Nullable PsiElement element, IElementType type) {
     return element instanceof PsiJavaToken && ((PsiJavaToken)element).getTokenType() == type;
   }
 
+  public static boolean isJavaToken(@Nullable PsiElement element, @NotNull TokenSet types) {
+    return element instanceof PsiJavaToken && types.contains(((PsiJavaToken)element).getTokenType());
+  }
+
   public static boolean isCatchParameter(@Nullable final PsiElement element) {
     return element instanceof PsiParameter && element.getParent() instanceof PsiCatchSection;
   }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaImportStatementElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaImportStatementElementType.java
index c7cdac775ee3..40f8994dda60 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaImportStatementElementType.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaImportStatementElementType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -61,23 +61,21 @@ public abstract class JavaImportStatementElementType extends JavaStubElementType
   }
 
   @Override
-  public PsiImportStatementStub createStub(final LighterAST tree,
-                                           final LighterASTNode node,
-                                           final StubElement parentStub) {
+  public PsiImportStatementStub createStub(LighterAST tree, LighterASTNode node, StubElement parentStub) {
     boolean isOnDemand = false;
     String refText = null;
 
-    for (final LighterASTNode child : tree.getChildren(node)) {
-      final IElementType type = child.getTokenType();
+    for (LighterASTNode child : tree.getChildren(node)) {
+      IElementType type = child.getTokenType();
       if (type == JavaElementType.JAVA_CODE_REFERENCE || type == JavaElementType.IMPORT_STATIC_REFERENCE) {
-        refText = SourceUtil.getTextSkipWhiteSpaceAndComments(tree, child);
+        refText = SourceUtil.getReferenceText(tree, child);
       }
       else if (type == JavaTokenType.ASTERISK) {
         isOnDemand = true;
       }
     }
 
-    final byte flags = PsiImportStatementStubImpl.packFlags(isOnDemand, node.getTokenType() == JavaElementType.IMPORT_STATIC_STATEMENT);
+    byte flags = PsiImportStatementStubImpl.packFlags(isOnDemand, node.getTokenType() == JavaElementType.IMPORT_STATIC_STATEMENT);
     return new PsiImportStatementStubImpl(parentStub, refText, flags);
   }
 
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
index e82a069f8f9b..ff8c80db3729 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/JavaLightStubBuilder.java
@@ -44,7 +44,7 @@ public class JavaLightStubBuilder extends LightStubBuilder {
     if (pkg != null) {
       LighterASTNode ref = LightTreeUtil.firstChildOfType(tree, pkg, JavaElementType.JAVA_CODE_REFERENCE);
       if (ref != null) {
-        refText = SourceUtil.getTextSkipWhiteSpaceAndComments(tree, ref);
+        refText = SourceUtil.getReferenceText(tree, ref);
       }
     }
     return new PsiJavaFileStubImpl((PsiJavaFile)file, StringRef.fromString(refText), false);
@@ -83,6 +83,9 @@ public class JavaLightStubBuilder extends LightStubBuilder {
   }
 
   private static boolean checkByTypes(IElementType parentType, IElementType nodeType) {
+    if (ElementType.IMPORT_STATEMENT_BASE_BIT_SET.contains(parentType)) {
+      return true;
+    }
     if (nodeType == JavaElementType.PARAMETER && parentType != JavaElementType.PARAMETER_LIST) {
       return true;
     }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java
index 9c294794d595..5cd2b0c2c810 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiJavaCodeReferenceElementImpl.java
@@ -686,7 +686,7 @@ public class PsiJavaCodeReferenceElementImpl extends CompositePsiElement impleme
   private String getTextSkipWhiteSpaceAndComments() {
     String whiteSpaceAndComments = myCachedTextSkipWhiteSpaceAndComments;
     if (whiteSpaceAndComments == null) {
-      myCachedTextSkipWhiteSpaceAndComments = whiteSpaceAndComments = SourceUtil.getTextSkipWhiteSpaceAndComments(this);
+      myCachedTextSkipWhiteSpaceAndComments = whiteSpaceAndComments = SourceUtil.getReferenceText(this);
     }
     return whiteSpaceAndComments;
   }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/SourceUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/SourceUtil.java
index 83480c53f254..83261a3bdcae 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/SourceUtil.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/SourceUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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,30 +20,67 @@ import com.intellij.lang.ASTNode;
 import com.intellij.lang.LighterAST;
 import com.intellij.lang.LighterASTNode;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.psi.JavaTokenType;
-import com.intellij.psi.PsiManager;
+import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.impl.source.DummyHolder;
 import com.intellij.psi.impl.source.SourceTreeToPsiMap;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.CharTable;
 import com.intellij.util.IncorrectOperationException;
-
+import org.jetbrains.annotations.NotNull;
 
 public class SourceUtil {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.SourceUtil");
 
+  private static final TokenSet REF_FILTER = TokenSet.orSet(
+    ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET, TokenSet.create(JavaElementType.ANNOTATION));
+
   private SourceUtil() { }
 
-  public static String getTextSkipWhiteSpaceAndComments(final ASTNode element) {
+  @NotNull
+  public static String getReferenceText(@NotNull PsiJavaCodeReferenceElement ref) {
+    final StringBuilder buffer = new StringBuilder();
+
+    ((TreeElement)ref.getNode()).acceptTree(new RecursiveTreeElementWalkingVisitor() {
+      @Override
+      public void visitLeaf(LeafElement leaf) {
+        if (!REF_FILTER.contains(leaf.getElementType())) {
+          buffer.append(leaf.getText());
+        }
+      }
+
+      @Override
+      public void visitComposite(CompositeElement composite) {
+        if (!REF_FILTER.contains(composite.getElementType())) {
+          super.visitComposite(composite);
+        }
+      }
+    });
+
+    return buffer.toString();
+  }
+
+  @NotNull
+  public static String getReferenceText(@NotNull LighterAST tree, @NotNull LighterASTNode node) {
+    return LightTreeUtil.toFilteredString(tree, node, REF_FILTER);
+  }
+
+  /** @deprecated use {@link AstBufferUtil#getTextSkippingWhitespaceComments(ASTNode)} (to remove in IDEA 13) */
+  @SuppressWarnings("UnusedDeclaration")
+  public static String getTextSkipWhiteSpaceAndComments(ASTNode element) {
     return AstBufferUtil.getTextSkippingWhitespaceComments(element);
   }
 
-  public static String getTextSkipWhiteSpaceAndComments(final LighterAST tree, final LighterASTNode node) {
+  /** @deprecated use {@link LightTreeUtil#toFilteredString(LighterAST, LighterASTNode, TokenSet)} (to remove in IDEA 13) */
+  @SuppressWarnings("UnusedDeclaration")
+  public static String getTextSkipWhiteSpaceAndComments(LighterAST tree, LighterASTNode node) {
     return LightTreeUtil.toFilteredString(tree, node, ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET);
   }
 
-  public static TreeElement addParenthToReplacedChild(final IElementType parenthType, TreeElement newChild, PsiManager manager) {
+  public static TreeElement addParenthToReplacedChild(@NotNull IElementType parenthType,
+                                                      @NotNull TreeElement newChild,
+                                                      @NotNull PsiManager manager) {
     CompositeElement parenthExpr = ASTFactory.composite(parenthType);
 
     TreeElement dummyExpr = (TreeElement)newChild.clone();
@@ -56,9 +93,8 @@ public class SourceUtil {
 
     try {
       CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(manager.getProject());
-      parenthExpr =
-      (CompositeElement)SourceTreeToPsiMap.psiElementToTree(
-        codeStyleManager.reformat(SourceTreeToPsiMap.treeElementToPsi(parenthExpr)));
+      PsiElement formatted = codeStyleManager.reformat(SourceTreeToPsiMap.treeToPsiNotNull(parenthExpr));
+      parenthExpr = (CompositeElement)SourceTreeToPsiMap.psiToTreeNotNull(formatted);
     }
     catch (IncorrectOperationException e) {
       LOG.error(e); // should not happen
@@ -68,7 +104,7 @@ public class SourceUtil {
     dummyExpr.rawReplaceWithList(newChild);
 
     newChild = parenthExpr;
-    // TODO remove explicit caches drop since this should be ok if we will use ChangeUtil for the modification 
+    // TODO remove explicit caches drop since this should be ok if we will use ChangeUtil for the modification
     TreeUtil.clearCaches(TreeUtil.getFileElement(newChild));
     return newChild;
   }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiPackageStatementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiPackageStatementImpl.java
index 1880639d7f3e..5a42715590ef 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiPackageStatementImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiPackageStatementImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -18,7 +18,6 @@ package com.intellij.psi.impl.source.tree.java;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.psi.*;
-import com.intellij.psi.impl.source.SourceTreeToPsiMap;
 import com.intellij.psi.impl.source.tree.*;
 import com.intellij.psi.tree.ChildRoleBase;
 import com.intellij.psi.tree.IElementType;
@@ -39,7 +38,7 @@ public class PsiPackageStatementImpl extends CompositePsiElement implements PsiP
   @Override
   public String getPackageName() {
     PsiJavaCodeReferenceElement ref = getPackageReference();
-    return ref == null ? null : SourceUtil.getTextSkipWhiteSpaceAndComments(SourceTreeToPsiMap.psiElementToTree(ref));
+    return ref == null ? null : SourceUtil.getReferenceText(ref);
   }
 
   @Override
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java
index e151d23bc405..2e84a197ab89 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiReferenceExpressionImpl.java
@@ -730,7 +730,7 @@ public class PsiReferenceExpressionImpl extends PsiReferenceExpressionBase imple
   private String getCachedTextSkipWhiteSpaceAndComments() {
     String whiteSpaceAndComments = myCachedTextSkipWhiteSpaceAndComments;
     if (whiteSpaceAndComments == null) {
-      myCachedTextSkipWhiteSpaceAndComments = whiteSpaceAndComments = SourceUtil.getTextSkipWhiteSpaceAndComments(this);
+      myCachedTextSkipWhiteSpaceAndComments = whiteSpaceAndComments = SourceUtil.getReferenceText(this);
     }
     return whiteSpaceAndComments;
   }
diff --git a/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java b/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java
index 5c91ddff01f4..a131ab5c8b6a 100644
--- a/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java
+++ b/java/java-tests/testSrc/com/intellij/psi/JavaStubBuilderTest.java
@@ -64,8 +64,8 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
 
   public void testClassDeclaration() {
     doTest("package p;" +
-           "class A implements I, J { }\n" +
-           "class B<K,V extends X> extends a/*skip*/.A { class I { } }\n" +
+           "class A implements I, J<I> { }\n" +
+           "class B<K, V extends X> extends a/*skip*/.A { class I { } }\n" +
            "@java.lang.Deprecated interface I { }\n" +
            "/** @deprecated just don't use */ @interface N { }",
 
@@ -75,7 +75,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
            "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
-           "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:I, J]\n" +
+           "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:I, J<I>]\n" +
            "  CLASS:PsiClassStub[name=B fqn=p.B]\n" +
            "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
            "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
@@ -348,7 +348,7 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "          THROWS_LIST:PsiRefListStub[THROWS_LIST:]\n");
   }
 
-  public void testAnnotations() throws Exception {
+  public void testAnnotations() {
     doTest("@Deprecated\n" +
            "@SuppressWarnings(\"UnusedDeclaration\")\n" +
            "class Foo { }",
@@ -367,6 +367,83 @@ public class JavaStubBuilderTest extends LightIdeaTestCase {
            "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:]\n");
   }
 
+  public void testTypeAnnotations() {
+    doTest("import j.u.@A C;\n" +
+           "import @A j.u.C;\n" +
+           "\n" +
+           "class C<@A T extends @A C> implements @A I<@A T> {\n" +
+           "  T<@A T1, @A ? extends @A T2> f;\n" +
+           "  void m(/*@A C this,*/ int p) throws @A E {\n" +
+           "    o.<@A1 C>m();\n" +
+           "    new <T> @A2 C();\n" +
+           "    C.@A3 B v = (@A4 C)v.new @A5 C();\n" +
+           "    m(@A6 C::m);\n" +
+           "    @A7 T @A8[] @A9[] a = new @A7 T @A8[0] @A9[0];\n" +
+           "  }\n" +
+           "}",
+
+           "PsiJavaFileStub []\n" +
+           "  IMPORT_LIST:PsiImportListStub\n" +
+           "    IMPORT_STATEMENT:PsiImportStatementStub[j.u.C]\n" +
+           "    IMPORT_STATEMENT:PsiImportStatementStub[j.u.C]\n" +
+           "  CLASS:PsiClassStub[name=C fqn=C]\n" +
+           "    MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "    TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
+           "      TYPE_PARAMETER:PsiTypeParameter[T]\n" +
+           "        ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "          ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "        EXTENDS_BOUND_LIST:PsiRefListStub[EXTENDS_BOUNDS_LIST:@A C]\n" +
+           "          ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "            ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "    EXTENDS_LIST:PsiRefListStub[EXTENDS_LIST:]\n" +
+           "    IMPLEMENTS_LIST:PsiRefListStub[IMPLEMENTS_LIST:@A I<@A T>]\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "    FIELD:PsiFieldStub[f:T<@A T1, @A ? extends @A T2>]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "    METHOD:PsiMethodStub[m:void]\n" +
+           "      MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      TYPE_PARAMETER_LIST:PsiTypeParameterListStub\n" +
+           "      PARAMETER_LIST:PsiParameterListStub\n" +
+           "        PARAMETER:PsiParameterStub[p:int]\n" +
+           "          MODIFIER_LIST:PsiModifierListStub[mask=4096]\n" +
+           "      THROWS_LIST:PsiRefListStub[THROWS_LIST:@A E]\n" +
+           "        ANNOTATION:PsiAnnotationStub[@A]\n" +
+           "          ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A1]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A2]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A3]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A4]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A5]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A6]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A7]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A8]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A9]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A7]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A8]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n" +
+           "      ANNOTATION:PsiAnnotationStub[@A9]\n" +
+           "        ANNOTATION_PARAMETER_LIST:PsiAnnotationParameterListStubImpl\n");
+  }
+
   public void testSOEProof() {
     final StringBuilder sb = new StringBuilder();
     final SecureRandom random = new SecureRandom();
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/tree/AstBufferUtil.java b/platform/core-impl/src/com/intellij/psi/impl/source/tree/AstBufferUtil.java
index 7a15892a325e..d3b09c11b0e4 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/tree/AstBufferUtil.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/tree/AstBufferUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -13,10 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-/*
- * @author max
- */
 package com.intellij.psi.impl.source.tree;
 
 import com.intellij.lang.ASTNode;
@@ -29,14 +25,17 @@ import com.intellij.util.text.StringFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * @author max
+ */
 public class AstBufferUtil {
-  private AstBufferUtil() {}
+  private AstBufferUtil() { }
 
   public static int toBuffer(@NotNull ASTNode element, @Nullable char[] buffer, int offset) {
     return toBuffer(element, buffer, offset, false);
   }
 
-  public static int toBuffer(@NotNull final ASTNode element, @Nullable final char[] buffer, int offset, final boolean skipWhitespaceAndComments) {
+  public static int toBuffer(@NotNull ASTNode element, @Nullable char[] buffer, int offset, boolean skipWhitespaceAndComments) {
     BufferVisitor visitor = new BufferVisitor(skipWhitespaceAndComments, skipWhitespaceAndComments, offset, buffer);
     ((TreeElement)element).acceptTree(visitor);
     return visitor.end;
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/tree/LightTreeUtil.java b/platform/core-impl/src/com/intellij/psi/impl/source/tree/LightTreeUtil.java
index 4002b1646ac8..c490e670dce6 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/tree/LightTreeUtil.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/tree/LightTreeUtil.java
@@ -28,6 +28,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.Collections;
 import java.util.List;
 
+@SuppressWarnings("ForLoopReplaceableByForEach")
 public class LightTreeUtil {
   private LightTreeUtil() { }
 
@@ -83,13 +84,14 @@ public class LightTreeUtil {
     return result != null ? result: Collections.<LighterASTNode>emptyList();
   }
 
+  @NotNull
   public static String toFilteredString(@NotNull LighterAST tree, @NotNull LighterASTNode node, @Nullable TokenSet skipTypes) {
     StringBuilder buffer = new StringBuilder(node.getEndOffset() - node.getStartOffset());
     toBuffer(tree, node, buffer, skipTypes);
     return buffer.toString();
   }
 
-  private static void toBuffer(@NotNull LighterAST tree, @NotNull LighterASTNode node, @NotNull StringBuilder buffer, @Nullable TokenSet skipTypes) {
+  public static void toBuffer(@NotNull LighterAST tree, @NotNull LighterASTNode node, @NotNull StringBuilder buffer, @Nullable TokenSet skipTypes) {
     if (skipTypes != null && skipTypes.contains(node.getTokenType())) return;
 
     if (node instanceof LighterASTTokenNode) {

From 704fadb625e3c4d20898f8bf0372ba03db6c1cf3 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 11:47:12 +0400
Subject: [PATCH 160/354] toString()

---
 platform/lang-api/src/com/intellij/facet/Facet.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/platform/lang-api/src/com/intellij/facet/Facet.java b/platform/lang-api/src/com/intellij/facet/Facet.java
index dc8ccd3431d3..cc991e677ce4 100644
--- a/platform/lang-api/src/com/intellij/facet/Facet.java
+++ b/platform/lang-api/src/com/intellij/facet/Facet.java
@@ -114,4 +114,8 @@ public class Facet<C extends FacetConfiguration> extends UserDataHolderBase impl
     myName = name;
   }
 
+  @Override
+  public String toString() {
+    return getName() + " (" + getModule().getName() + ")";
+  }
 }

From d401e2a618247df6a1c3d4a1fe0de75417db5463 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Tue, 26 Feb 2013 09:44:22 +0100
Subject: [PATCH 161/354] IDEA-95612 The Darcula tooltips colors are ugly and
 not customizable

---
 .../hint/ParameterInfoComponent.java            | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java
index 3880ca5872e1..251d1b4552a3 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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,10 +20,7 @@ import com.intellij.lang.parameterInfo.ParameterInfoHandler;
 import com.intellij.lang.parameterInfo.ParameterInfoUIContextEx;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.psi.PsiElement;
-import com.intellij.ui.Gray;
-import com.intellij.ui.ScrollPaneFactory;
-import com.intellij.ui.SideBorder;
-import com.intellij.ui.StrikeoutLabel;
+import com.intellij.ui.*;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
 
@@ -43,14 +40,14 @@ class ParameterInfoComponent extends JPanel{
   private final OneElementComponent[] myPanels;
 
   private static final Color BACKGROUND_COLOR = HintUtil.INFORMATION_COLOR;
-  private static final Color FOREGROUND_COLOR = Gray._0;
+  private static final Color FOREGROUND_COLOR = JBColor.foreground;
 //  private static final Color DISABLED_BACKGROUND_COLOR = HintUtil.INFORMATION_COLOR;
   private static final Color DISABLED_FOREGROUND_COLOR = Gray._128;
-  private static final Color HIGHLIGHTED_BORDER_COLOR = new Color(231, 254, 234);
+  private static final Color HIGHLIGHTED_BORDER_COLOR = new JBColor(new Color(231, 254, 234), Gray._100);
   private final Font NORMAL_FONT;
   private final Font BOLD_FONT;
 
-  private static final Border BOTTOM_BORDER = new SideBorder(Color.lightGray, SideBorder.BOTTOM);
+  private static final Border BOTTOM_BORDER = new SideBorder(JBColor.LIGHT_GRAY, SideBorder.BOTTOM);
   private static final Border BACKGROUND_BORDER = BorderFactory.createLineBorder(BACKGROUND_COLOR);
 
   protected int myWidthLimit;
@@ -112,13 +109,13 @@ class ParameterInfoComponent extends JPanel{
                                              boolean isDisabledBeforeHighlight,
                                              Color background) {
       myPanels[i].setup(text, highlightStartOffset, highlightEndOffset, isDisabled, strikeout, isDisabledBeforeHighlight, background);
-      myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : BOTTOM_BORDER);
+      myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : new SideBorder(new JBColor(JBColor.LIGHT_GRAY, Gray._90), SideBorder.BOTTOM));
     }
 
     @Override
     public void setupUIComponentPresentation(final String[] texts, final EnumSet<Flag>[] flags, final Color background) {
       myPanels[i].setup(texts, flags, background);
-      myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : BOTTOM_BORDER);
+      myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : new SideBorder(new JBColor(JBColor.LIGHT_GRAY, Gray._90), SideBorder.BOTTOM));
     }
 
     @Override

From 83947b54b5f429e471a4a2ea8f4297a7eb81f6f7 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Tue, 26 Feb 2013 09:49:51 +0100
Subject: [PATCH 162/354] better colors for vcs gutter

---
 colorSchemes/src/colorSchemes/Darcula.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 5debddc000c6..98e661029565 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -4,7 +4,7 @@
   <option name="EDITOR_FONT_SIZE" value="12" />
   <option name="EDITOR_FONT_NAME" value="Menlo" />
   <colors>
-    <option name="ADDED_LINES_COLOR" value="d6822" />
+    <option name="ADDED_LINES_COLOR" value="3f6232" />
     <option name="ANNOTATIONS_COLOR" value="8b999f" />
     <option name="CARET_COLOR" value="bbbbbb" />
     <option name="CARET_ROW_COLOR" value="323232" />
@@ -29,7 +29,7 @@
     <option name="INDENT_GUIDE" value="373737" />
     <option name="LINE_NUMBERS_COLOR" value="888888" />
     <option name="METHOD_SEPARATORS_COLOR" value="4d4d4d" />
-    <option name="MODIFIED_LINES_COLOR" value="7180" />
+    <option name="MODIFIED_LINES_COLOR" value="3c4b4e" />
     <option name="NOTIFICATION_BACKGROUND" value="5c5c42" />
     <option name="READONLY_FRAGMENT_BACKGROUND" value="" />
     <option name="RECURSIVE_CALL_ATTRIBUTES" value="574300" />
@@ -1519,7 +1519,7 @@
     </option>
     <option name="TODO_DEFAULT_ATTRIBUTES">
       <value>
-        <option name="FOREGROUND" value="bc9458" />
+        <option name="FOREGROUND" value="a8c023" />
         <option name="FONT_TYPE" value="2" />
       </value>
     </option>

From 3e86f9ecc774987c2ba8d1b780b0ddbf1ac4fc10 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Tue, 26 Feb 2013 10:10:46 +0100
Subject: [PATCH 163/354] IDEA-101875 Directory Diff font is black under
 darcula

---
 .../src/com/intellij/ide/diff/DirDiffOperation.java          | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/ide/diff/DirDiffOperation.java b/platform/platform-api/src/com/intellij/ide/diff/DirDiffOperation.java
index c0c090e076f6..3f2ba20aaf81 100644
--- a/platform/platform-api/src/com/intellij/ide/diff/DirDiffOperation.java
+++ b/platform/platform-api/src/com/intellij/ide/diff/DirDiffOperation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -17,6 +17,7 @@ package com.intellij.ide.diff;
 
 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.vcs.FileStatus;
+import com.intellij.ui.JBColor;
 import com.intellij.util.ui.EmptyIcon;
 
 import javax.swing.*;
@@ -52,6 +53,6 @@ public enum DirDiffOperation {
       case EQUAL:
       case NONE:
     }
-    return Color.BLACK;
+    return JBColor.foreground;
   }
 }

From f094e6f168ba5a3e0e29956ba93d0bc72f9bdaad Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 10:00:08 +0100
Subject: [PATCH 164/354] Test renamed

---
 ...iNameHelperTest.java => NameUtilTest.java} | 33 +++++++++++++++----
 1 file changed, 27 insertions(+), 6 deletions(-)
 rename platform/platform-tests/testSrc/com/intellij/psi/{PsiNameHelperTest.java => NameUtilTest.java} (54%)

diff --git a/platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java b/platform/platform-tests/testSrc/com/intellij/psi/NameUtilTest.java
similarity index 54%
rename from platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java
rename to platform/platform-tests/testSrc/com/intellij/psi/NameUtilTest.java
index 8ba390ceee77..d5a7e2d49519 100644
--- a/platform/platform-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/psi/NameUtilTest.java
@@ -1,41 +1,62 @@
+/*
+ * Copyright 2000-2013 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.psi;
 
-import junit.framework.TestCase;
+import com.intellij.psi.codeStyle.NameUtil;
+import org.junit.Test;
 
 import java.util.Arrays;
 
-import com.intellij.psi.codeStyle.NameUtil;
+import static org.junit.Assert.assertEquals;
 
 /**
- *  @author dsl
+ * @author dsl
  */
-public class PsiNameHelperTest extends TestCase {
+public class NameUtilTest {
+  @Test
   public void testSplitIntoWords1() throws Exception {
     assertSplitEquals(new String[]{"I", "Base"}, "IBase");
   }
 
+  @Test
   public void testSplitIntoWords2() throws Exception {
     assertSplitEquals(new String[]{"Order", "Index"}, "OrderIndex");
   }
 
+  @Test
   public void testSplitIntoWords3() throws Exception {
     assertSplitEquals(new String[]{"order", "Index"}, "orderIndex");
   }
 
+  @Test
   public void testSplitIntoWords4() throws Exception {
     assertSplitEquals(new String[]{"Order", "Index"}, "Order_Index");
   }
 
+  @Test
   public void testSplitIntoWords5() throws Exception {
     assertSplitEquals(new String[]{"ORDER", "INDEX"}, "ORDER_INDEX");
   }
 
-
+  @Test
   public void testSplitIntoWords6() throws Exception {
     assertSplitEquals(new String[]{"gg", "J"}, "ggJ");
   }
 
-  private void assertSplitEquals(String[] expected, String name) {
+  private static void assertSplitEquals(String[] expected, String name) {
     final String[] result = NameUtil.splitNameIntoWords(name);
     assertEquals(Arrays.asList(expected).toString(), Arrays.asList(result).toString());
   }

From 6847032559a22913f6bfb85673eb743b42db8585 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 10:11:12 +0100
Subject: [PATCH 165/354] Layout fixed

---
 lib/required_for_dist.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/required_for_dist.txt b/lib/required_for_dist.txt
index ebe07dfdb5f8..d58ee448bd8d 100644
--- a/lib/required_for_dist.txt
+++ b/lib/required_for_dist.txt
@@ -39,7 +39,7 @@ serviceMessages.jar
 snappy-java-1.0.5-M2.jar
 trove4j.jar
 velocity.jar
-winp-1.16-patched.jar
+winp-1.17-patched.jar
 xbean.jar
 xerces.jar
 xmlrpc-2.0.jar

From d8274020f0729e6a9a7c3bafc9c35e927e904b42 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Tue, 26 Feb 2013 13:12:10 +0400
Subject: [PATCH 166/354] IDEA-94662 Favorites: no border between content and
 add/remove panel + extra border under the add/remove panel

---
 .../intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
index 6c5cf7f9f8d0..a412a8c3632d 100644
--- a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
+++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesTreeViewPanel.java
@@ -215,7 +215,7 @@ public class FavoritesTreeViewPanel extends JPanel implements DataProvider, Dock
     exportActionButton.setShortcut(exportToTextFileAction.getShortcutSet());
 
     final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myTree)
-      .setLineBorder(0, 0, 1, 0)
+      .initPosition()
       .disableAddAction().disableRemoveAction().disableDownAction().disableUpAction()
       .addExtraAction(addActionButton)
       .addExtraAction(editActionButton)

From de7131e6a81ca66067ef3ab211fbbd521b13977a Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Tue, 26 Feb 2013 13:55:24 +0400
Subject: [PATCH 167/354] CR-IC-41 Vertical line block match disapear view line
 in java code (IDEA-99572)

1. Limit 'shiftForward()' by line end offset;
2. Minor refactoring;
3. Don't show indent guide for commented lines which would remove indent on un-commenting;
---
 .../daemon/indentGuide/IndentGuideTest.groovy |  12 +-
 .../codeInsight/daemon/impl/IndentsPass.java  | 274 ++++++++++--------
 .../com/intellij/util/text/CharArrayUtil.java |  31 +-
 3 files changed, 183 insertions(+), 134 deletions(-)

diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/indentGuide/IndentGuideTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/indentGuide/IndentGuideTest.groovy
index 3fe81493e751..88af209beebf 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/indentGuide/IndentGuideTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/indentGuide/IndentGuideTest.groovy
@@ -43,8 +43,8 @@ class Test {
   |  //test();
   |  if (true) {
   |  |  int i = 1;
-  |  |  |
-//|  |  |  comment;
+  |  |  
+//|  |    int k;
   |  |  int j = 1;
   |  }
   }
@@ -141,8 +141,12 @@ class Test {
     myFixture.configureByText("${getTestName(false)}.java", testData.documentText)
     CodeInsightTestFixtureImpl.instantiateAndRun(myFixture.file, myFixture.editor, ArrayUtilRt.EMPTY_INT_ARRAY, false)
     IndentsModelImpl model = myFixture.editor.indentsModel as IndentsModelImpl
-    assertEquals("expected to find ${testData.guides.size()} indent guide but got ${model.indents.size()}",
-                 testData.guides.size(), model.indents.size())
+    assertEquals(
+      "expected to find ${testData.guides.size()} indent guides (" +
+      "${testData.guides.collect { startLine, endLine, level -> "$level ($startLine-$endLine)"}}) " +
+      "but got ${model.indents.size()} (${model.indents})",
+      testData.guides.size(), model.indents.size()
+    )
 
     testData.guides.each {
       def descriptor = model.getDescriptor(it[0], it[1])
diff --git a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
index d70e7223649d..66421a2e4176 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
@@ -26,7 +26,6 @@ import com.intellij.openapi.editor.*;
 import com.intellij.openapi.editor.colors.EditorColors;
 import com.intellij.openapi.editor.colors.EditorColorsScheme;
 import com.intellij.openapi.editor.ex.EditorEx;
-import com.intellij.openapi.editor.highlighter.EditorHighlighter;
 import com.intellij.openapi.editor.highlighter.HighlighterIterator;
 import com.intellij.openapi.editor.markup.CustomHighlighterRenderer;
 import com.intellij.openapi.editor.markup.HighlighterTargetArea;
@@ -44,8 +43,10 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import com.intellij.util.DocumentUtil;
 import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.ContainerUtilRt;
 import com.intellij.util.containers.IntStack;
 import com.intellij.util.text.CharArrayUtil;
+import gnu.trove.TIntIntHashMap;
 import org.jetbrains.annotations.NotNull;
 
 import java.awt.*;
@@ -93,8 +94,9 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
 
       final CharSequence chars = doc.getCharsSequence();
       do {
-        int pos = doc.getLineStartOffset(startLine);
-        off = CharArrayUtil.shiftForward(chars, pos, " \t");
+        int start = doc.getLineStartOffset(startLine);
+        int end = doc.getLineEndOffset(startLine);
+        off = CharArrayUtil.shiftForward(chars, start, end, " \t");
         startLine--;
       }
       while (startLine > 1 && off < doc.getTextLength() && chars.charAt(off) == '\n');
@@ -296,7 +298,10 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
   private List<IndentGuideDescriptor> buildDescriptors() {
     if (!myEditor.getSettings().isIndentGuidesShown()) return Collections.emptyList();
 
-    int[] lineIndents = calcIndents();
+    IndentsCalculator calculator = new IndentsCalculator();
+    calculator.calculate();
+    int[] lineIndents = calculator.lineIndents;
+    TIntIntHashMap effectiveCommentColumns = calculator.indentAfterUncomment;
 
     List<IndentGuideDescriptor> descriptors = new ArrayList<IndentGuideDescriptor>();
 
@@ -316,7 +321,18 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
         final int level = indents.pop();
         int startLine = lines.pop();
         if (level > 0) {
-          descriptors.add(createDescriptor(level, startLine, line, chars));
+          boolean addDescriptor = effectiveCommentColumns.contains(startLine); // Indent started at comment
+          if (!addDescriptor) {
+            for (int i = startLine; i < line; i++) {
+              if (level != lineIndents[i] && level != effectiveCommentColumns.get(i)) {
+                addDescriptor = true;
+                break;
+              }
+            }
+          }
+          if (addDescriptor) {
+            descriptors.add(createDescriptor(level, startLine, line, chars));
+          }
         }
       }
 
@@ -332,8 +348,8 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
     while (!indents.empty()) {
       ProgressManager.checkCanceled();
       final int level = indents.pop();
+      int startLine = lines.pop();
       if (level > 0) {
-        int startLine = lines.pop();
         descriptors.add(createDescriptor(level, startLine, myDocument.getLineCount(), chars));
       }
     }
@@ -351,109 +367,8 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
       return true;
     }
     int startOffset = document.getLineStartOffset(line);
-    return CharArrayUtil.shiftForward(chars, startOffset, " \t") >= myDocument.getLineEndOffset(line);
-  }
-
-  /**
-   * Calculates line indents for the {@link #myDocument target document}.
-   *
-   * @return line indents array which uses lines as indices
-   */
-  @NotNull
-  private int[] calcIndents() {
-    Context context = new Context(myDocument, myFile.getLanguage(), myEditor.getHighlighter());
-    int[] lineIndents = context.lineIndents;
-    final FileType fileType = myFile.getFileType();
-    int prevLineIndent = -1;
-
-    for (int line = 0; line < lineIndents.length; line++) {
-      ProgressManager.checkCanceled();
-      int lineStart = myDocument.getLineStartOffset(line);
-      int lineEnd = myDocument.getLineEndOffset(line);
-      final int nonWhitespaceOffset = CharArrayUtil.shiftForward(context.chars, lineStart, " \t");
-      final int column;
-      if (nonWhitespaceOffset == lineEnd) {
-        lineIndents[line] = -1; // Blank line marker
-      }
-      else if (nonWhitespaceOffset > lineEnd) {
-        lineIndents[line] = calcIndent(context, line, lineStart, lineEnd, 0);
-        prevLineIndent = lineIndents[line];
-      }
-      else {
-        column = myEditor.calcColumnNumber(nonWhitespaceOffset, line);
-        if (prevLineIndent > 0 && prevLineIndent > column) {
-          lineIndents[line] = calcIndent(context, line, nonWhitespaceOffset, lineEnd, column);
-        }
-        else {
-          lineIndents[line] = column;
-        }
-        prevLineIndent = lineIndents[line];
-      }
-    }
-
-    int topIndent = 0;
-    for (int line = 0; line < lineIndents.length; line++) {
-      ProgressManager.checkCanceled();
-      if (lineIndents[line] >= 0) {
-        topIndent = lineIndents[line];
-      }
-      else {
-        int startLine = line;
-        while (line < lineIndents.length && lineIndents[line] < 0) {
-          //noinspection AssignmentToForLoopParameter
-          line++;
-        }
-
-        int bottomIndent = line < lineIndents.length ? lineIndents[line] : topIndent;
-
-        int indent = Math.min(topIndent, bottomIndent);
-        if (bottomIndent < topIndent) {
-          int nonWhitespaceOffset = CharArrayUtil.shiftForward(context.chars, myDocument.getLineStartOffset(line), " \t");
-          HighlighterIterator iterator = context.highlighter.createIterator(nonWhitespaceOffset);
-          if (BraceMatchingUtil.isRBraceToken(iterator, context.chars, fileType)) {
-            indent = topIndent;
-          }
-        }
-
-        for (int blankLine = startLine; blankLine < line; blankLine++) {
-          assert lineIndents[blankLine] == -1;
-          lineIndents[blankLine] = Math.min(topIndent, indent);
-        }
-
-        //noinspection AssignmentToForLoopParameter
-        line--; // will be incremented back at the end of the loop;
-      }
-    }
-
-    return lineIndents;
-  }
-
-  /**
-   * Tries to calculate given line's indent column assuming that there might be a comment at the given indent offset
-   * (see {@link #parseComments(IElementType)}).
-   * 
-   * @param context         current calculation context
-   * @param line            target line
-   * @param indentOffset    start indent offset to use for the given line
-   * @param lineEndOffset   given line's end offset
-   * @param fallbackColumn  column to return if it's not possible to apply comment-specific indent calculation rules 
-   * @return                given line's indent column to use
-   */
-  private int calcIndent(@NotNull Context context, int line, int indentOffset, int lineEndOffset, int fallbackColumn) {
-    final HighlighterIterator it = context.highlighter.createIterator(indentOffset);
-    if (context.comments.contains(it.getTokenType()) && indentOffset == it.getStart()) {
-      String prefix = COMMENT_PREFIXES.get(it.getTokenType());
-      if (prefix == null) {
-        prefix = parseComments(it.getTokenType());
-      }
-      if (!NO_COMMENT_INFO_MARKER.equals(prefix)) {
-        final int indentInsideCommentOffset = CharArrayUtil.shiftForward(context.chars, indentOffset + prefix.length(), " \t");
-        if (indentInsideCommentOffset < lineEndOffset) {
-          return myEditor.calcColumnNumber(indentInsideCommentOffset, line);
-        }
-      }
-    }
-    return fallbackColumn;
+    int endOffset = document.getLineEndOffset(line);
+    return CharArrayUtil.shiftForward(chars, startOffset, endOffset, " \t") >= myDocument.getLineEndOffset(line);
   }
 
   /**
@@ -461,7 +376,7 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
    * <p/>
    * Example:
    * <pre>
-   *   it (true) {
+   *   if (true) {
    *     int i1;
    * //    int i2;
    *     int i3;
@@ -478,7 +393,7 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
    *                     {@link #NO_COMMENT_INFO_MARKER} otherwise
    */
   @NotNull
-  private static String parseComments(@NotNull IElementType commentType) {
+  private static String getCommentPrefix(@NotNull IElementType commentType) {
     Commenter c = LanguageCommenters.INSTANCE.forLanguage(commentType.getLanguage());
     if (!(c instanceof CodeDocumentationAwareCommenter)) {
       COMMENT_PREFIXES.put(commentType, NO_COMMENT_INFO_MARKER);
@@ -521,21 +436,132 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
     return answer != 0 ? answer : r.getEndOffset() - h.getEndOffset();
   }
 
-  /**
-   * 'Parameter object' for {@link #calcIndent(Context, int, int, int, int)}.
-   */
-  private static class Context {
+  private class IndentsCalculator {
 
-    @NotNull public final int[]             lineIndents;
-    @NotNull public final CharSequence      chars;
-    @NotNull public final TokenSet          comments;
-    @NotNull public final EditorHighlighter highlighter;
+    @NotNull public final Map<Language, TokenSet> myComments = ContainerUtilRt.newHashMap();
 
-    Context(@NotNull Document document, @NotNull Language language, @NotNull EditorHighlighter highlighter) {
-      lineIndents = new int[document.getLineCount()];
-      chars = document.getCharsSequence();
-      comments = LanguageParserDefinitions.INSTANCE.forLanguage(language).getCommentTokens();
-      this.highlighter = highlighter;
+    /**
+     * We need to treat specially commented lines. Consider a situation like below:
+     * <pre>
+     *   void test() {
+     *     if (true) {
+     *       int i;
+     *  //     int j;
+     *     }
+     *   }
+     * </pre>
+     * We don't want to show indent guide after 'int i;' line because un-commented line below ('int j;') would have the same indent
+     * level. That's why we remember 'indents after un-comment' at this collection.
+     */
+    @NotNull public final TIntIntHashMap/* line -> indent column after un-comment */ indentAfterUncomment = new TIntIntHashMap();
+
+    @NotNull public final int[]        lineIndents;
+    @NotNull public final CharSequence myChars;
+
+    IndentsCalculator() {
+      assert myDocument != null;
+      lineIndents = new int[myDocument.getLineCount()];
+      myChars = myDocument.getCharsSequence();
+    }
+
+    /**
+     * Calculates line indents for the {@link #myDocument target document}.
+     */
+    void calculate() {
+      final FileType fileType = myFile.getFileType();
+      int prevLineIndent = -1;
+
+      for (int line = 0; line < lineIndents.length; line++) {
+        ProgressManager.checkCanceled();
+        int lineStart = myDocument.getLineStartOffset(line);
+        int lineEnd = myDocument.getLineEndOffset(line);
+        final int nonWhitespaceOffset = CharArrayUtil.shiftForward(myChars, lineStart, lineEnd, " \t");
+        final int column;
+        if (nonWhitespaceOffset == lineEnd) {
+          lineIndents[line] = -1; // Blank line marker
+        }
+        else {
+          column = myEditor.calcColumnNumber(nonWhitespaceOffset, line);
+          if (prevLineIndent > 0 && prevLineIndent > column) {
+            lineIndents[line] = calcIndent(line, nonWhitespaceOffset, lineEnd, column);
+          }
+          else {
+            lineIndents[line] = column;
+          }
+          prevLineIndent = lineIndents[line];
+        }
+      }
+
+      int topIndent = 0;
+      for (int line = 0; line < lineIndents.length; line++) {
+        ProgressManager.checkCanceled();
+        if (lineIndents[line] >= 0) {
+          topIndent = lineIndents[line];
+        }
+        else {
+          int startLine = line;
+          while (line < lineIndents.length && lineIndents[line] < 0) {
+            //noinspection AssignmentToForLoopParameter
+            line++;
+          }
+
+          int bottomIndent = line < lineIndents.length ? lineIndents[line] : topIndent;
+
+          int indent = Math.min(topIndent, bottomIndent);
+          if (bottomIndent < topIndent) {
+            int lineStart = myDocument.getLineStartOffset(line);
+            int lineEnd = myDocument.getLineEndOffset(line);
+            int nonWhitespaceOffset = CharArrayUtil.shiftForward(myChars, lineStart, lineEnd, " \t");
+            HighlighterIterator iterator = myEditor.getHighlighter().createIterator(nonWhitespaceOffset);
+            if (BraceMatchingUtil.isRBraceToken(iterator, myChars, fileType)) {
+              indent = topIndent;
+            }
+          }
+
+          for (int blankLine = startLine; blankLine < line; blankLine++) {
+            assert lineIndents[blankLine] == -1;
+            lineIndents[blankLine] = Math.min(topIndent, indent);
+          }
+
+          //noinspection AssignmentToForLoopParameter
+          line--; // will be incremented back at the end of the loop;
+        }
+      }
+    }
+
+    /**
+     * Tries to calculate given line's indent column assuming that there might be a comment at the given indent offset
+     * (see {@link #getCommentPrefix(IElementType)}).
+     *
+     * @param line            target line
+     * @param indentOffset    start indent offset to use for the given line
+     * @param lineEndOffset   given line's end offset
+     * @param fallbackColumn  column to return if it's not possible to apply comment-specific indent calculation rules 
+     * @return given line's indent column to use
+     */
+    private int calcIndent(int line, int indentOffset, int lineEndOffset, int fallbackColumn) {
+      final HighlighterIterator it = myEditor.getHighlighter().createIterator(indentOffset);
+      IElementType tokenType = it.getTokenType();
+      Language language = tokenType.getLanguage();
+      TokenSet comments = myComments.get(language);
+      if (comments == null) {
+        myComments.put(language, comments = LanguageParserDefinitions.INSTANCE.forLanguage(language).getCommentTokens());
+      }
+      if (comments.contains(tokenType) && indentOffset == it.getStart()) {
+        String prefix = COMMENT_PREFIXES.get(tokenType);
+        if (prefix == null) {
+          prefix = getCommentPrefix(tokenType);
+        }
+        if (!NO_COMMENT_INFO_MARKER.equals(prefix)) {
+          final int indentInsideCommentOffset = CharArrayUtil.shiftForward(myChars, indentOffset + prefix.length(), lineEndOffset, " \t");
+          if (indentInsideCommentOffset < lineEndOffset) {
+            int indent = myEditor.calcColumnNumber(indentInsideCommentOffset, line);
+            indentAfterUncomment.put(line, indent - prefix.length());
+            return indent;
+          }
+        }
+      }
+      return fallbackColumn;
     }
   }
 }
diff --git a/platform/util/src/com/intellij/util/text/CharArrayUtil.java b/platform/util/src/com/intellij/util/text/CharArrayUtil.java
index 5e4dc45a4823..f62a1645d607 100644
--- a/platform/util/src/com/intellij/util/text/CharArrayUtil.java
+++ b/platform/util/src/com/intellij/util/text/CharArrayUtil.java
@@ -194,17 +194,36 @@ public class CharArrayUtil {
   }
 
   public static int shiftForward(@NotNull CharSequence buffer, int offset, @NotNull String chars) {
-    while (true) {
-      if (offset >= buffer.length()) break;
+    return shiftForward(buffer, offset, buffer.length(), chars);
+  }
+
+  /**
+   * Tries to find an offset from the <code>[startOffset; endOffset)</code> interval such that a char from the given buffer is
+   * not contained at the given 'chars' string.
+   * <p/>
+   * Example:
+   * {@code buffer="abc", startOffset=0, endOffset = 3, chars="ab". Result: 2}
+   * 
+   * @param buffer       target buffer which symbols should be checked
+   * @param startOffset  start offset to use within the given buffer (inclusive)
+   * @param endOffset    end offset to use within the given buffer (exclusive)
+   * @param chars        pass-through symbols
+   * @return             offset from the <code>[startOffset; endOffset)</code> which points to a symbol at the given buffer such
+   *                     as that that symbol is not contained at the given 'chars';
+   *                     <code>endOffset</code> otherwise
+   */
+  public static int shiftForward(@NotNull CharSequence buffer, final int startOffset, final int endOffset, @NotNull String chars) {
+    for (int offset = startOffset, limit = Math.min(endOffset, buffer.length()); offset < limit; offset++) {
       char c = buffer.charAt(offset);
-      int i;      
+      int i;
       for (i = 0; i < chars.length(); i++) {
         if (c == chars.charAt(i)) break;
       }
-      if (i == chars.length()) break;
-      offset++;
+      if (i >= chars.length()) {
+        return offset;
+      }
     }
-    return offset;
+    return endOffset;
   }
 
   public static int shiftForwardCarefully(@NotNull CharSequence buffer, int offset, @NotNull String chars) {

From bd722b923e1041ae68b8fd3b13f241b08b84d18e Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Sat, 23 Feb 2013 14:27:52 +0400
Subject: [PATCH 168/354] name reference element for GrAnnotation

---
 .../auxiliary/annotation/GrAnnotationImpl.java     | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationImpl.java
index fc2ef913bb3a..8ea5f6890a00 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/auxiliary/annotation/GrAnnotationImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,6 +20,7 @@ import com.intellij.lang.ASTNode;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiImplUtil;
+import com.intellij.psi.impl.light.LightClassReference;
 import com.intellij.psi.impl.source.tree.java.PsiAnnotationImpl;
 import com.intellij.psi.meta.PsiMetaData;
 import com.intellij.util.PairFunction;
@@ -29,6 +30,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
+import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField;
@@ -92,7 +94,15 @@ public class GrAnnotationImpl extends GrStubElementBase<GrAnnotationStub> implem
 
   @Nullable
   public PsiJavaCodeReferenceElement getNameReferenceElement() {
-    return null;
+    final GroovyResolveResult resolveResult = getClassReference().advancedResolve();
+    final PsiElement resolved = resolveResult.getElement();
+
+    if (resolved instanceof PsiClass) {
+      return new LightClassReference(getManager(), getClassReference().getText(), (PsiClass)resolved, resolveResult.getSubstitutor());
+    }
+    else {
+      return null;
+    }
   }
 
   public PsiAnnotationMemberValue findAttributeValue(@Nullable String attributeName) {

From 3242d58e136a8cd6de9ced8358e571e0bee9e33f Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Sat, 23 Feb 2013 18:49:35 +0400
Subject: [PATCH 169/354] cleanup

---
 .../lang/psi/impl/signatures/GrClosureSignatureUtil.java    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
index e91ae3074e7f..49af31d31828 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -622,7 +622,7 @@ public class GrClosureSignatureUtil {
 
   @Nullable
   public static Map<GrExpression, Pair<PsiParameter, PsiType>> mapArgumentsToParameters(@NotNull GroovyResolveResult resolveResult,
-                                                                                        @NotNull GroovyPsiElement context,
+                                                                                        @NotNull PsiElement context,
                                                                                         final boolean partial,
                                                                                         final boolean eraseArgs,
                                                                                         @NotNull final GrNamedArgument[] namedArgs,
@@ -683,7 +683,7 @@ public class GrClosureSignatureUtil {
                                                                @NotNull GrNamedArgument[] namedArgs,
                                                                @NotNull GrExpression[] expressionArgs,
                                                                @NotNull GrClosableBlock[] closureArguments,
-                                                               @NotNull GroovyPsiElement context,
+                                                               @NotNull PsiElement context,
                                                                boolean partial, boolean eraseArgs) {
     List<InnerArg> innerArgs = new ArrayList<InnerArg>();
 

From 345252345832376177cfaee1c4ea372048c33085 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Mon, 25 Feb 2013 12:06:54 +0400
Subject: [PATCH 170/354] IDEA-99587 Groovy 2.1 : @DelegatesTo without Target
 implemented

---
 .../blocks/GrClosableBlockImpl.java           | 170 +++++++++++++++++-
 .../lang/psi/util/GroovyCommonClassNames.java |   5 +-
 .../lang/resolve/DeclarationCacheKey.java     |   7 +-
 .../groovy/lang/resolve/ResolveUtil.java      |  33 +++-
 .../resolve/ResolveWithDelegatesToTest.groovy | 152 ++++++++++++++++
 5 files changed, 347 insertions(+), 20 deletions(-)
 create mode 100644 plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
index 9bf71be71c4f..ad790640fed8 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -17,6 +17,7 @@
 package org.jetbrains.plugins.groovy.lang.psi.impl.statements.blocks;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.openapi.util.Pair;
 import com.intellij.psi.*;
 import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.tree.IElementType;
@@ -24,6 +25,7 @@ import com.intellij.psi.util.CachedValueProvider;
 import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.util.ArrayUtil;
 import com.intellij.util.Function;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.NullableFunction;
@@ -33,8 +35,13 @@ import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
+import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrStringInjection;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameterList;
@@ -44,15 +51,19 @@ import org.jetbrains.plugins.groovy.lang.psi.impl.GrClosureType;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiElementImpl;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
 import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
+import org.jetbrains.plugins.groovy.lang.psi.impl.signatures.GrClosureSignatureUtil;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.params.GrParameterListImpl;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.ClosureSyntheticParameter;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightVariable;
+import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
 import org.jetbrains.plugins.groovy.lang.resolve.MethodTypeInferencer;
 import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ResolverProcessor;
 import org.jetbrains.plugins.groovy.refactoring.GroovyNamesUtil;
 
+import java.util.Map;
+
 import static org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames.GROOVY_LANG_CLOSURE;
 
 /**
@@ -78,19 +89,158 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
 
   public boolean processDeclarations(final @NotNull PsiScopeProcessor processor,
                                      final @NotNull ResolveState _state,
-                                     final PsiElement lastParent,
+                                     final @Nullable PsiElement lastParent,
                                      final @NotNull PsiElement place) {
     if (lastParent == null) return true;
 
     ResolveState state = _state.put(ResolverProcessor.RESOLVE_CONTEXT, this);
     if (!super.processDeclarations(processor, _state, lastParent, place)) return false;
     if (!processParameters(processor, _state, state, place)) return false;
-    if (!processOwner(processor, state)) return false;
+    if (!ResolveUtil.processElement(processor, getOwner(), _state)) return false;
+    if (!processOwnerAndDelegate(processor, state, place)) return false;
     if (!processClosureClassMembers(processor, state, lastParent, place)) return false;
 
     return true;
   }
 
+  private boolean processOwnerAndDelegate(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @NotNull PsiElement place) {
+    Boolean result = processDelegatesTo(processor, state, place);
+    if (result != null) return result.booleanValue();
+
+    if (!processOwner(processor, state)) return false;
+    return true;
+  }
+
+  @Nullable
+  private Boolean processDelegatesTo(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @NotNull PsiElement place) {
+    final GrCall call = getContainingCall();
+
+    if (call == null) return null;
+
+    final Map<GrExpression, Pair<PsiParameter, PsiType>> map = mapArgumentsToParameters(place, call);
+    if (map == null) {
+      return null;
+    }
+
+    final Pair<PsiParameter, PsiType> pair = map.get(this);
+    final PsiParameter parameter = pair.getFirst();
+    final PsiModifierList modifierList = parameter.getModifierList();
+    if (modifierList == null) return null;
+
+    final PsiAnnotation annotation = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO);
+    if (annotation == null) return null;
+
+    final PsiAnnotationMemberValue strategy = annotation.findAttributeValue("strategy");
+
+    switch (getStrategyValue(strategy)) {
+      case 0:
+        if (!processOwner(processor, state)) return false;
+        if (!processDelegate(annotation, processor, state, place)) return false;
+        return true;
+      case 1:
+        if (!processDelegate(annotation, processor, state, place)) return false;
+        if (!processOwner(processor, state)) return false;
+        return true;
+      case 2:
+        if (!processOwner(processor, state)) return false;
+        return true;
+      case 3:
+        if (!processDelegate(annotation, processor, state, place)) return false;
+        return true;
+      case 4:
+        return true;
+      default:
+        return null;
+    }
+  }
+
+  @Nullable
+  private static Map<GrExpression, Pair<PsiParameter, PsiType>> mapArgumentsToParameters(@NotNull PsiElement place, @NotNull GrCall call) {
+    GroovyResolveResult result = GroovyResolveResult.EMPTY_RESULT;
+
+    if (call instanceof GrMethodCall) {
+      final GrExpression invoked = ((GrMethodCall)call).getInvokedExpression();
+      if (invoked instanceof GrReferenceExpression) {
+        final GroovyResolveResult[] results = ((GrReferenceExpression)invoked).resolveByShape();
+        if (results.length == 1) {
+          result = results[0];
+        }
+      }
+    }
+    else {
+      result = call.advancedResolve();
+    }
+
+    return GrClosureSignatureUtil.mapArgumentsToParameters(
+      result, place, false, true, call.getNamedArguments(), call.getExpressionArguments(), call.getClosureArguments()
+    );
+  }
+
+  private static boolean processDelegate(@NotNull PsiAnnotation delegatesTo,
+                                         @NotNull PsiScopeProcessor processor,
+                                         @NotNull ResolveState state,
+                                         @NotNull PsiElement place) {
+    final PsiAnnotationMemberValue value = delegatesTo.findAttributeValue("value");
+    if (value instanceof GrReferenceExpression) {
+      final PsiType type = extractTypeFromClassType(((GrReferenceExpression)value).getType());
+      if (type != null) {
+        return ResolveUtil.processAllDeclarations(type, processor, state, place);
+      }
+    }
+
+    return true;
+  }
+
+  @Nullable
+  private static PsiType extractTypeFromClassType(@Nullable PsiType type) {
+    if (type instanceof PsiClassType) {
+      final PsiClass resolved = ((PsiClassType)type).resolve();
+      if (resolved != null && CommonClassNames.JAVA_LANG_CLASS.equals(resolved.getQualifiedName())) {
+        final PsiType[] parameters = ((PsiClassType)type).getParameters();
+        if (parameters.length == 1) {
+          return parameters[0];
+        }
+      }
+    }
+    return null;
+  }
+
+
+  private static int getStrategyValue(@Nullable PsiAnnotationMemberValue strategy) {
+    if (strategy == null) return -1;
+
+    final String text = strategy.getText();
+    if ("0".equals(text)) return 0;
+    if ("1".equals(text)) return 1;
+    if ("2".equals(text)) return 2;
+    if ("3".equals(text)) return 3;
+    if ("4".equals(text)) return 4;
+
+    if (text.endsWith("OWNER_FIRST")) return 0;
+    if (text.endsWith("DELEGATE_FIRST")) return 1;
+    if (text.endsWith("OWNER_ONLY")) return 2;
+    if (text.endsWith("DELEGATE_ONLY")) return 3;
+    if (text.endsWith("TO_SELF")) return 4;
+
+    return -1;
+  }
+
+  @Nullable
+  private GrCall getContainingCall() {
+    final PsiElement parent = getParent();
+    if (parent instanceof GrCall && ArrayUtil.contains(this, ((GrCall)parent).getClosureArguments())) {
+      return (GrCall)parent;
+    }
+    else if (parent instanceof GrArgumentList) {
+      final PsiElement parent1 = parent.getParent();
+      if (parent1 instanceof GrCall) {
+        return (GrCall)parent1;
+      }
+    }
+
+    return null;
+  }
+
   private boolean processClosureClassMembers(PsiScopeProcessor processor,
                                              ResolveState state, PsiElement lastParent,
                                              PsiElement place) {
@@ -100,7 +250,7 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
 
       if (place instanceof GroovyPsiElement) {
         GrClosureType closureType = GrClosureType.create(this, false /*if it is 'true' need-to-prevent-recursion triggers*/);
-        if (!ResolveUtil.processNonCodeMembers(closureType, processor, (GroovyPsiElement)place, state)) {
+        if (!ResolveUtil.processNonCodeMembers(closureType, processor, place, state)) {
           return false;
         }
       }
@@ -126,12 +276,14 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     return true;
   }
 
-  private boolean processOwner(PsiScopeProcessor processor, ResolveState state) {
-    String nameHint = ResolveUtil.getNameHint(processor);
-    if (nameHint == null || nameHint.equals(OWNER_NAME)) {
-      if (!processor.execute(getOwner(), state)) return false;
+  private boolean processOwner(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state) {
+    final PsiElement parent = this.getParent();
+    if (parent instanceof GroovyPsiElement) {
+      return ResolveUtil.treeWalkUp((GroovyPsiElement)parent, processor, true, state);
+    }
+    else {
+      return true;
     }
-    return true;
   }
 
   private boolean isItAlreadyDeclared(PsiElement place) {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
index 5432a8e95737..f30b6ea8353d 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
@@ -55,12 +55,13 @@ public final class GroovyCommonClassNames {
   @NonNls public static final String GROOVY_TRANSFORM_TYPE_CHECKED = "groovy.transform.TypeChecked";
   @NonNls public static final String GROOVY_TRANSFORM_TYPE_CHECKING_MODE = "groovy.transform.TypeCheckingMode";
   @NonNls public static final String JAVA_LANG_CHAR_SEQUENCE = "java.lang.CharSequence";
-  public static final String GROOVY_TRANSFORM_INHERIT_CONSTRUCTORS = "groovy.transform.InheritConstructors";
-  public static final String GROOVY_LANG_IMMUTABLE = "groovy.lang.Immutable";
+  @NonNls public static final String GROOVY_TRANSFORM_INHERIT_CONSTRUCTORS = "groovy.transform.InheritConstructors";
+  @NonNls public static final String GROOVY_LANG_IMMUTABLE = "groovy.lang.Immutable";
   @NonNls public static final String GROOVY_LANG_META_CLASS = "groovy.lang.MetaClass";
   @NonNls public static final String GROOVY_LANG_GROOVY_CALLABLE = "groovy.lang.GroovyCallable";
   @NonNls public static final String GROOVY_TRANSFORM_ANNOTATION_COLLECTOR = "groovy.transform.AnnotationCollector";
   @NonNls public static final String GROOVY_LANG_NEWIFY = "groovy.lang.Newify";
+  @NonNls public static final String GROOVY_LANG_DELEGATES_TO = "groovy.lang.DelegatesTo";
 
 
   private GroovyCommonClassNames() {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
index a21ab1256c74..8c17a19a3acf 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
@@ -29,6 +29,7 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ClassHint;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ResolverProcessor;
 
@@ -118,6 +119,7 @@ class DeclarationCacheKey {
       @Override
       public boolean process(PsiElement scope, PsiElement lastParent) {
         result.add(collectScopeDeclarations(scope, lastParent, place));
+        if (scope instanceof GrClosableBlock) return false; //closures tree walk up themselves
         return true;
       }
     });
@@ -127,7 +129,7 @@ class DeclarationCacheKey {
   private DeclarationHolder collectScopeDeclarations(PsiElement scope, PsiElement lastParent, GroovyPsiElement place) {
     MyCollectProcessor plainCollector = new MyCollectProcessor(scope);
     MyCollectProcessor nonCodeCollector = new MyCollectProcessor(scope);
-    ResolveUtil.doProcessDeclarations(place, lastParent, scope, plainCollector, nonCode ? nonCodeCollector : null);
+    ResolveUtil.doProcessDeclarations(place, lastParent, scope, plainCollector, nonCode ? nonCodeCollector : null, ResolveState.initial());
     return new DeclarationHolder(scope, plainCollector.declarations, nonCodeCollector.declarations);
   }
 
@@ -136,7 +138,8 @@ class DeclarationCacheKey {
       CachedValuesManager.getManager(place.getProject()).getCachedValue(place, VALUE_PROVIDER);
     List<DeclarationHolder> declarations = cache.get(this);
     if (declarations == null) {
-      cache.putIfAbsent(this, declarations = collectDeclarations(place));
+      declarations = collectDeclarations(place);
+      cache.putIfAbsent(this, declarations);
     }
     return declarations;
   }
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
index 6a9e5853bade..16719cae080d 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
@@ -92,7 +92,24 @@ public class ResolveUtil {
    * @param processNonCodeMethods - this parameter tells us if we need non code members
    * @return
    */
-  public static boolean treeWalkUp(@NotNull final GroovyPsiElement place, final PsiScopeProcessor processor, boolean processNonCodeMethods) {
+  public static boolean treeWalkUp(@NotNull final GroovyPsiElement place,
+                                   @NotNull final PsiScopeProcessor processor,
+                                   boolean processNonCodeMethods) {
+    return treeWalkUp(place, processor, processNonCodeMethods, ResolveState.initial());
+  }
+
+  /**
+   *
+   * @param place - place to start tree walk up
+   * @param processor
+   * @param processNonCodeMethods - this parameter tells us if we need non code members
+   * @param state
+   * @return
+   */
+  public static boolean treeWalkUp(@NotNull final GroovyPsiElement place,
+                                   @NotNull final PsiScopeProcessor processor,
+                                   boolean processNonCodeMethods,
+                                   @NotNull final ResolveState state) {
     ClassHint hint = processor.getHint(ClassHint.KEY);
     if (hint != null) {
       return new DeclarationCacheKey(getNameHint(processor), hint, processNonCodeMethods).processCachedDeclarations(place, processor);
@@ -102,21 +119,23 @@ public class ResolveUtil {
     return PsiTreeUtil.treeWalkUp(place, null, new PairProcessor<PsiElement, PsiElement>() {
       @Override
       public boolean process(PsiElement scope, PsiElement lastParent) {
-        if (!doProcessDeclarations(place, lastParent, scope, substituteProcessor(processor, scope), nonCodeProcessor)) {
+        if (!doProcessDeclarations(place, lastParent, scope, substituteProcessor(processor, scope), nonCodeProcessor, state)) {
           return false;
         }
+        if (scope instanceof GrClosableBlock) return false; //closures tree walk up themselves
         issueLevelChangeEvents(processor, scope);
         return true;
       }
     });
   }
 
-  static boolean doProcessDeclarations(GroovyPsiElement place,
-                                       PsiElement lastParent,
-                                       PsiElement scope,
+  static boolean doProcessDeclarations(@NotNull GroovyPsiElement place,
+                                       @Nullable PsiElement lastParent,
+                                       @NotNull PsiElement scope,
                                        @NotNull PsiScopeProcessor plainProcessor,
-                                       @Nullable PsiScopeProcessor nonCodeProcessor) {
-    if (!scope.processDeclarations(plainProcessor, ResolveState.initial(), lastParent, place)) return false;
+                                       @Nullable PsiScopeProcessor nonCodeProcessor,
+                                       @NotNull ResolveState state) {
+    if (!scope.processDeclarations(plainProcessor, state, lastParent, place)) return false;
     if (nonCodeProcessor != null && !processScopeNonCodeMethods(place, lastParent, nonCodeProcessor, scope)) return false;
     return true;
   }
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy
new file mode 100644
index 000000000000..866083ba9fa9
--- /dev/null
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.groovy.lang.resolve
+
+import com.intellij.psi.PsiMethod
+import org.jetbrains.plugins.groovy.LightGroovyTestCase
+
+/**
+ * @author Max Medvedev
+ */
+class ResolveWithDelegatesToTest extends LightGroovyTestCase {
+  @Override
+  protected String getBasePath() { null }
+
+  void testShouldChooseMethodFromOwner() {
+    assertScript '''
+            class Delegate {
+                int foo() { 2 }
+            }
+            class Owner {
+                int foo() { 1 }
+                int doIt(@DelegatesTo(Delegate) Closure cl) {
+                    cl.delegate = new Delegate()
+                    cl() as int
+                }
+                int test() {
+                    doIt {
+                        @ASTTest(phase=INSTRUCTION_SELECTION, value={
+                            node = node.rightExpression
+                            def target = node.getNodeMetaData(DIRECT_METHOD_CALL_TARGET)
+                            assert target != null
+                            assert target.declaringClass.name == 'Owner'
+                        })
+                        def x = fo<caret>o() // as the delegation strategy is owner first, should return 1
+                        x
+                    }
+                }
+            }
+            def o = new Owner()
+            assert o.test() == 1
+        ''', 'Owner'
+  }
+
+  void testShouldChooseMethodFromDelegate() {
+    assertScript '''
+            class Delegate {
+                int foo() { 2 }
+            }
+            class Owner {
+                int foo() { 1 }
+                int doIt(@DelegatesTo(strategy=Closure.DELEGATE_FIRST, value=Delegate) Closure cl) {
+                    cl.delegate = new Delegate()
+                    cl.resolveStrategy = Closure.DELEGATE_FIRST
+                    cl() as int
+                }
+                int test() {
+                    doIt {
+                        @ASTTest(phase=INSTRUCTION_SELECTION, value={
+                            node = node.rightExpression
+                            def target = node.getNodeMetaData(DIRECT_METHOD_CALL_TARGET)
+                            assert target != null
+                            assert target.declaringClass.name == 'Delegate'
+                        })
+                        def x = f<caret>oo() // as the delegation strategy is delegate first, should return 2
+                        x
+                    }
+                }
+            }
+            def o = new Owner()
+            assert o.test() == 2
+        ''', 'Delegate'
+  }
+
+  void testShouldAcceptMethodCall() {
+    assertScript '''
+            class ExecSpec {
+                boolean called = false
+                void foo() {
+                    called = true
+                }
+            }
+
+            ExecSpec spec = new ExecSpec()
+
+            void exec(ExecSpec spec, @DelegatesTo(value=ExecSpec, strategy=Closure.DELEGATE_FIRST) Closure param) {
+                param.delegate = spec
+                param()
+            }
+
+            exec(spec) {
+                fo<caret>o() // should be recognized because param is annotated with @DelegatesTo(ExecSpec)
+            }
+            assert spec.isCalled()
+        ''', 'ExecSpec'
+  }
+
+  void testCallMethodFromOwner() {
+    assertScript '''
+            class Xml {
+                boolean called = false
+                void bar() { called = true }
+                void foo(@DelegatesTo(Xml)Closure cl) { cl.delegate=this;cl() }
+            }
+            def mylist = [1]
+            def xml = new Xml()
+            xml.foo {
+             mylist.each { b<caret>ar() }
+            }
+            assert xml.called
+        ''', 'Xml'
+  }
+
+
+
+  void testInConstructor() {
+    assertScript '''
+        class Foo {
+          def foo() {}
+        }
+
+        class Abc {
+          def Abc(@DelegatesTo(Foo) Closure cl) {
+          }
+        }
+
+        new Abc({fo<caret>o()})
+''', 'Foo'
+  }
+
+  void assertScript(String text, String resolvedClass) {
+    myFixture.configureByText('_a.groovy', text)
+
+    final ref = myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
+    final resolved = ref.resolve()
+    assertInstanceOf(resolved, PsiMethod)
+    final containingClass = resolved.containingClass.name
+    assertEquals(resolvedClass, containingClass)
+  }
+}

From 0aa42d9bd21ea5aa0a9e48e6404876e0eee71c32 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Mon, 25 Feb 2013 15:43:18 +0400
Subject: [PATCH 171/354] IDEA-99587 Groovy 2.1 : @DelegatesTo, correct
 highlighting

---
 plugins/groovy/src/META-INF/plugin.xml        |  1 +
 .../DelegatesToAnnotationChecker.java         | 63 +++++++++++++++++++
 .../GroovyHighlightingTest.groovy             | 13 ++++
 3 files changed, 77 insertions(+)
 create mode 100644 plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/DelegatesToAnnotationChecker.java

diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml
index 703f940e64d6..3c82201b05b5 100644
--- a/plugins/groovy/src/META-INF/plugin.xml
+++ b/plugins/groovy/src/META-INF/plugin.xml
@@ -166,6 +166,7 @@
     <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.GrabAnnotationChecker"/>
     <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.GrAliasAnnotationChecker"/>
     <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.AnnotationCollectorChecker" order="first"/>
+    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.DelegatesToAnnotationChecker"/>
   </extensions>
 
   <extensions defaultExtensionNs="com.intellij.properties">
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/DelegatesToAnnotationChecker.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/DelegatesToAnnotationChecker.java
new file mode 100644
index 000000000000..fcb6d65af29a
--- /dev/null
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/DelegatesToAnnotationChecker.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.groovy.annotator;
+
+import com.intellij.lang.annotation.AnnotationHolder;
+import com.intellij.psi.PsiAnnotationMemberValue;
+import com.intellij.psi.PsiAnnotationOwner;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameterList;
+import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
+
+/**
+ * checks the following case:
+ * <p/>
+ * def foo(@DelegatesTo.Target def targetArg, @DelegatesTo Closure cl) {}
+ *
+ * @author Max Medvedev
+ */
+
+public class DelegatesToAnnotationChecker extends CustomAnnotationChecker {
+  @Override
+  public boolean checkArgumentList(@NotNull AnnotationHolder holder, @NotNull GrAnnotation annotation) {
+    if (!GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO.equals(annotation.getQualifiedName())) return false;
+
+    final PsiAnnotationMemberValue valueAttribute = annotation.findAttributeValue("value");
+
+    if (valueAttribute == null) {
+      final PsiAnnotationOwner owner = annotation.getOwner();
+      if (owner instanceof GrModifierList) {
+        final PsiElement parent1 = ((GrModifierList)owner).getParent();
+        if (parent1 instanceof GrParameter) {
+          final PsiElement parent = parent1.getParent();
+          if (parent instanceof GrParameterList) {
+            for (GrParameter parameter : ((GrParameterList)parent).getParameters()) {
+              if (parameter.getModifierList().findAnnotation(GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO_TARGET) != null) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
index e580466e0d0a..42e250f45e38 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/highlighting/GroovyHighlightingTest.groovy
@@ -1120,4 +1120,17 @@ print(<error descr="Collection literal contains named and expression arguments a
 ''')
   }
 
+  void testDelegatesToApplicability() {
+    testHighlighting('''
+      def with(@DelegatesTo.Target Object target, @DelegatesTo Closure arg) {
+        arg.delegate = target
+        arg()
+      }
+
+      def with2(Object target, @<error descr="Missed attributes: value">DelegatesTo</error> Closure arg) {
+        arg.delegate = target
+        arg()
+      }
+''')
+  }
 }
\ No newline at end of file

From 97e663ce1e6775e911c13706bb7e19baae7056e6 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Mon, 25 Feb 2013 19:42:43 +0400
Subject: [PATCH 172/354] IDEA-99587 Groovy 2.1 : @DelegatesTo with @Target

---
 .../signatures/GrClosureSignatureUtil.java    |  40 +--
 .../blocks/GrClosableBlockImpl.java           | 151 ++---------
 .../statements/blocks/GrDelegatesToUtil.java  | 244 ++++++++++++++++++
 .../groovy/lang/psi/util/GdkMethodUtil.java   |  33 +--
 .../lang/psi/util/GroovyCommonClassNames.java |   1 +
 .../groovy/lang/resolve/ResolveUtil.java      |   3 +-
 .../resolve/ResolveWithDelegatesToTest.groovy | 180 +++++++++++++
 7 files changed, 491 insertions(+), 161 deletions(-)
 create mode 100644 plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrDelegatesToUtil.java

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
index 49af31d31828..7afea41d2400 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/signatures/GrClosureSignatureUtil.java
@@ -431,11 +431,12 @@ public class GrClosureSignatureUtil {
       }
       if (cur == params.length) return partial ? map : null;
       if (params[cur].isOptional()) optionalArgs--;
-      if (!isAssignableByConversion(params[cur].getType(), typeComputer.fun(args[i]), context)) return partial ? map : null;
-      map[cur] = new ArgInfo<Arg>(args[i]);
+      final PsiType type = typeComputer.fun(args[i]);
+      if (!isAssignableByConversion(params[cur].getType(), type, context)) return partial ? map : null;
+      map[cur] = new ArgInfo<Arg>(args[i], type);
     }
     for (int i = 0; i < map.length; i++) {
-      if (map[i] == null) map[i] = new ArgInfo<Arg>(Collections.<Arg>emptyList(), false);
+      if (map[i] == null) map[i] = new ArgInfo<Arg>(Collections.<Arg>emptyList(), false, null);
     }
     return map;
   }
@@ -515,7 +516,7 @@ public class GrClosureSignatureUtil {
       }
       if (isApplicableInternal(0, 0, false, notOptionals)) {
         for (int i = 0; i < map.length; i++) {
-          if (map[i] == null) map[i] = new ArgInfo<Arg>(false);
+          if (map[i] == null) map[i] = new ArgInfo<Arg>(false, null);
         }
         return map;
       }
@@ -539,7 +540,7 @@ public class GrClosureSignatureUtil {
         if (params[curParam].isOptional()) {
           if (isAssignableByConversion(params[curParam].getType(), types[curArg], context) &&
               isApplicableInternal(curParam + 1, curArg + 1, false, notOptional)) {
-            map[curParam] = new ArgInfo<Arg>(args[curArg]);
+            map[curParam] = new ArgInfo<Arg>(args[curArg], types[curArg]);
             return true;
           }
           skipOptionals = true;
@@ -549,7 +550,7 @@ public class GrClosureSignatureUtil {
             for (int i = startParam; i < curParam; i++) map[i] = null;
             return false;
           }
-          map[curParam] = new ArgInfo<Arg>(args[curArg]);
+          map[curParam] = new ArgInfo<Arg>(args[curArg], types[curArg]);
           notOptional--;
           curArg++;
           curParam++;
@@ -564,7 +565,7 @@ public class GrClosureSignatureUtil {
         }
         varargs.add(args[curArg]);
       }
-      map[paramLength] = new ArgInfo<Arg>(varargs, true);
+      map[paramLength] = new ArgInfo<Arg>(varargs, true, new PsiEllipsisType(vararg));
       return true;
     }
   }
@@ -589,20 +590,20 @@ public class GrClosureSignatureUtil {
 
     public List<ArgType> args;
     public final boolean isMultiArg;
+    public final PsiType type;
 
-    public ArgInfo(List<ArgType> args, boolean multiArg) {
+    public ArgInfo(List<ArgType> args, boolean multiArg, PsiType type) {
       this.args = args;
       isMultiArg = multiArg;
+      this.type = type;
     }
 
-    public ArgInfo(ArgType arg) {
-      this.args = Collections.singletonList(arg);
-      this.isMultiArg = false;
+    public ArgInfo(ArgType arg, PsiType type) {
+      this(Collections.singletonList(arg), false, type);
     }
 
-    public ArgInfo(boolean isMultiArg) {
-      this.args = Collections.emptyList();
-      this.isMultiArg = isMultiArg;
+    public ArgInfo(boolean isMultiArg, PsiType type) {
+      this(Collections.<ArgType>emptyList(), isMultiArg, type);
     }
 
     public static <ArgType> ArgInfo<ArgType>[] empty_array() {
@@ -729,7 +730,7 @@ public class GrClosureSignatureUtil {
     ArgInfo<PsiElement>[] map = new ArgInfo[innerMap.length];
     int i = 0;
     if (hasNamedArgs) {
-      map[i] = new ArgInfo<PsiElement>(innerMap[i].args.iterator().next().list, true);
+      map[i] = new ArgInfo<PsiElement>(innerMap[i].args.iterator().next().list, true, innerArgs.get(i).type);
       i++;
     }
 
@@ -744,7 +745,7 @@ public class GrClosureSignatureUtil {
           argList.addAll(arg.list);
         }
         boolean multiArg = innerArg.isMultiArg || argList.size() > 1;
-        map[i] = new ArgInfo<PsiElement>(argList, multiArg);
+        map[i] = new ArgInfo<PsiElement>(argList, multiArg, innerArg.type);
       }
     }
 
@@ -919,8 +920,9 @@ public class GrClosureSignatureUtil {
     List<Pair<Integer, PsiType>> errors = new ArrayList<Pair<Integer, PsiType>>(maxErrorCount);
 
     for (int i = 0; i < params.length; i++) {
-      if (isAssignableByConversion(params[i].getType(), typeComputer.fun(args[i]), context)) {
-        map[i] = new ArgInfo<Arg>(args[i]);
+      final PsiType type = typeComputer.fun(args[i]);
+      if (isAssignableByConversion(params[i].getType(), type, context)) {
+        map[i] = new ArgInfo<Arg>(args[i], type);
       }
       else if (params[i].getType() instanceof PsiArrayType && i == params.length - 1) {
         if (i + 1 == args.length) {
@@ -933,7 +935,7 @@ public class GrClosureSignatureUtil {
             if (errorCount > maxErrorCount) return null;
             errors.add(new Pair<Integer, PsiType>(i, ellipsis));
           }
-          map[i] = new ArgInfo<Arg>(args[i]);
+          map[i] = new ArgInfo<Arg>(args[i], type);
         }
       }
       else {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
index ad790640fed8..4981b0732ab2 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
@@ -17,7 +17,6 @@
 package org.jetbrains.plugins.groovy.lang.psi.impl.statements.blocks;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.Pair;
 import com.intellij.psi.*;
 import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.tree.IElementType;
@@ -25,23 +24,18 @@ import com.intellij.psi.util.CachedValueProvider;
 import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.ArrayUtil;
 import com.intellij.util.Function;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.NullableFunction;
+import groovy.lang.Closure;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
-import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrStringInjection;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameterList;
@@ -51,19 +45,15 @@ import org.jetbrains.plugins.groovy.lang.psi.impl.GrClosureType;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiElementImpl;
 import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
 import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
-import org.jetbrains.plugins.groovy.lang.psi.impl.signatures.GrClosureSignatureUtil;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil;
 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.params.GrParameterListImpl;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.ClosureSyntheticParameter;
 import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightVariable;
-import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
 import org.jetbrains.plugins.groovy.lang.resolve.MethodTypeInferencer;
 import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ResolverProcessor;
 import org.jetbrains.plugins.groovy.refactoring.GroovyNamesUtil;
 
-import java.util.Map;
-
 import static org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames.GROOVY_LANG_CLOSURE;
 
 /**
@@ -113,137 +103,48 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
 
   @Nullable
   private Boolean processDelegatesTo(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @NotNull PsiElement place) {
-    final GrCall call = getContainingCall();
-
-    if (call == null) return null;
-
-    final Map<GrExpression, Pair<PsiParameter, PsiType>> map = mapArgumentsToParameters(place, call);
-    if (map == null) {
+    GrDelegatesToUtil.DelegatesToInfo info = GrDelegatesToUtil.getDelegateToInfo(place, this);
+    if (info == null) {
       return null;
     }
 
-    final Pair<PsiParameter, PsiType> pair = map.get(this);
-    final PsiParameter parameter = pair.getFirst();
-    final PsiModifierList modifierList = parameter.getModifierList();
-    if (modifierList == null) return null;
-
-    final PsiAnnotation annotation = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO);
-    if (annotation == null) return null;
-
-    final PsiAnnotationMemberValue strategy = annotation.findAttributeValue("strategy");
-
-    switch (getStrategyValue(strategy)) {
-      case 0:
+    switch (info.getStrategy()) {
+      case Closure.OWNER_FIRST:
         if (!processOwner(processor, state)) return false;
-        if (!processDelegate(annotation, processor, state, place)) return false;
+        if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
         return true;
-      case 1:
-        if (!processDelegate(annotation, processor, state, place)) return false;
+      case Closure.DELEGATE_FIRST:
+        if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
         if (!processOwner(processor, state)) return false;
         return true;
-      case 2:
+      case Closure.OWNER_ONLY:
         if (!processOwner(processor, state)) return false;
         return true;
-      case 3:
-        if (!processDelegate(annotation, processor, state, place)) return false;
+      case Closure.DELEGATE_ONLY:
+        if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
         return true;
-      case 4:
+      case Closure.TO_SELF:
         return true;
       default:
         return null;
     }
   }
 
-  @Nullable
-  private static Map<GrExpression, Pair<PsiParameter, PsiType>> mapArgumentsToParameters(@NotNull PsiElement place, @NotNull GrCall call) {
-    GroovyResolveResult result = GroovyResolveResult.EMPTY_RESULT;
-
-    if (call instanceof GrMethodCall) {
-      final GrExpression invoked = ((GrMethodCall)call).getInvokedExpression();
-      if (invoked instanceof GrReferenceExpression) {
-        final GroovyResolveResult[] results = ((GrReferenceExpression)invoked).resolveByShape();
-        if (results.length == 1) {
-          result = results[0];
-        }
-      }
-    }
-    else {
-      result = call.advancedResolve();
-    }
-
-    return GrClosureSignatureUtil.mapArgumentsToParameters(
-      result, place, false, true, call.getNamedArguments(), call.getExpressionArguments(), call.getClosureArguments()
-    );
-  }
-
-  private static boolean processDelegate(@NotNull PsiAnnotation delegatesTo,
-                                         @NotNull PsiScopeProcessor processor,
+  private static boolean processDelegate(@NotNull PsiScopeProcessor processor,
                                          @NotNull ResolveState state,
-                                         @NotNull PsiElement place) {
-    final PsiAnnotationMemberValue value = delegatesTo.findAttributeValue("value");
-    if (value instanceof GrReferenceExpression) {
-      final PsiType type = extractTypeFromClassType(((GrReferenceExpression)value).getType());
-      if (type != null) {
-        return ResolveUtil.processAllDeclarations(type, processor, state, place);
-      }
+                                         @NotNull PsiElement place,
+                                         @Nullable final PsiType classToDelegate) {
+    if (classToDelegate != null) {
+      return ResolveUtil.processAllDeclarations(classToDelegate, processor, state, place);
     }
 
     return true;
   }
 
-  @Nullable
-  private static PsiType extractTypeFromClassType(@Nullable PsiType type) {
-    if (type instanceof PsiClassType) {
-      final PsiClass resolved = ((PsiClassType)type).resolve();
-      if (resolved != null && CommonClassNames.JAVA_LANG_CLASS.equals(resolved.getQualifiedName())) {
-        final PsiType[] parameters = ((PsiClassType)type).getParameters();
-        if (parameters.length == 1) {
-          return parameters[0];
-        }
-      }
-    }
-    return null;
-  }
-
-
-  private static int getStrategyValue(@Nullable PsiAnnotationMemberValue strategy) {
-    if (strategy == null) return -1;
-
-    final String text = strategy.getText();
-    if ("0".equals(text)) return 0;
-    if ("1".equals(text)) return 1;
-    if ("2".equals(text)) return 2;
-    if ("3".equals(text)) return 3;
-    if ("4".equals(text)) return 4;
-
-    if (text.endsWith("OWNER_FIRST")) return 0;
-    if (text.endsWith("DELEGATE_FIRST")) return 1;
-    if (text.endsWith("OWNER_ONLY")) return 2;
-    if (text.endsWith("DELEGATE_ONLY")) return 3;
-    if (text.endsWith("TO_SELF")) return 4;
-
-    return -1;
-  }
-
-  @Nullable
-  private GrCall getContainingCall() {
-    final PsiElement parent = getParent();
-    if (parent instanceof GrCall && ArrayUtil.contains(this, ((GrCall)parent).getClosureArguments())) {
-      return (GrCall)parent;
-    }
-    else if (parent instanceof GrArgumentList) {
-      final PsiElement parent1 = parent.getParent();
-      if (parent1 instanceof GrCall) {
-        return (GrCall)parent1;
-      }
-    }
-
-    return null;
-  }
-
-  private boolean processClosureClassMembers(PsiScopeProcessor processor,
-                                             ResolveState state, PsiElement lastParent,
-                                             PsiElement place) {
+  private boolean processClosureClassMembers(@NotNull PsiScopeProcessor processor,
+                                             @NotNull ResolveState state,
+                                             @Nullable PsiElement lastParent,
+                                             @NotNull PsiElement place) {
     final PsiClass closureClass = GroovyPsiManager.getInstance(getProject()).findClassWithCache(GROOVY_LANG_CLOSURE, getResolveScope());
     if (closureClass != null) {
       if (!closureClass.processDeclarations(processor, state, lastParent, place)) return false;
@@ -258,10 +159,10 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     return true;
   }
 
-  private boolean processParameters(PsiScopeProcessor processor,
-                                    ResolveState _state,
-                                    ResolveState state,
-                                    PsiElement place) {
+  private boolean processParameters(@NotNull PsiScopeProcessor processor,
+                                    @NotNull ResolveState _state,
+                                    @NotNull ResolveState state,
+                                    @NotNull PsiElement place) {
     if (hasParametersSection()) {
       for (GrParameter parameter : getParameters()) {
         if (!ResolveUtil.processElement(processor, parameter, _state)) return false;
@@ -286,7 +187,7 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     }
   }
 
-  private boolean isItAlreadyDeclared(PsiElement place) {
+  private boolean isItAlreadyDeclared(@Nullable PsiElement place) {
     while (place != this && place != null) {
       if (place instanceof GrClosableBlock &&
           !((GrClosableBlock)place).hasParametersSection() &&
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrDelegatesToUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrDelegatesToUtil.java
new file mode 100644
index 000000000000..a7282b689ce7
--- /dev/null
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrDelegatesToUtil.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.groovy.lang.psi.impl.statements.blocks;
+
+import com.intellij.psi.*;
+import com.intellij.util.ArrayUtil;
+import groovy.lang.Closure;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
+import org.jetbrains.plugins.groovy.lang.psi.api.signatures.GrClosureSignature;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral;
+import org.jetbrains.plugins.groovy.lang.psi.impl.signatures.GrClosureSignatureUtil;
+import org.jetbrains.plugins.groovy.lang.psi.util.GdkMethodUtil;
+import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
+
+/**
+ * @author Max Medvedev
+ */
+public class GrDelegatesToUtil {
+  @Nullable
+  static DelegatesToInfo getDelegateToInfo(@NotNull PsiElement place, @NotNull final GrClosableBlock closableBlock) {
+    GrCall call = getContainingCall(closableBlock);
+    if (call == null) return null;
+
+    GroovyResolveResult result = resolveCall(call);
+
+    if (GdkMethodUtil.isWithOrIdentity(result)) {
+      final GrExpression qualifier = inferCallQualifier((GrMethodCall)call);
+      if (qualifier == null) return null;
+
+      return new DelegatesToInfo(qualifier.getType(), Closure.DELEGATE_FIRST);
+    }
+
+    final GrClosureSignature signature = GrClosureSignatureUtil.createSignature(result);
+    if (signature == null) return null;
+
+    final GrClosureSignatureUtil.ArgInfo<PsiElement>[] map = GrClosureSignatureUtil.mapParametersToArguments(
+      signature, call.getNamedArguments(), call.getExpressionArguments(), call.getClosureArguments(), place, false, true
+    );
+
+    if (map == null) {
+      return null;
+    }
+
+    final PsiParameter parameter = findParameter(closableBlock, map, result);
+    if (parameter == null) return null;
+
+    final PsiModifierList modifierList = parameter.getModifierList();
+    if (modifierList == null) return null;
+
+    final PsiAnnotation delegatesTo = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO);
+    if (delegatesTo == null) return null;
+
+    final PsiType type = inferDelegateType(delegatesTo, map);
+    if (type == null) return null;
+
+    final int strategyValue = getStrategyValue(delegatesTo.findAttributeValue("strategy"));
+    return new DelegatesToInfo(type, strategyValue);
+  }
+
+  @Nullable
+  private static PsiParameter findParameter(@NotNull GrClosableBlock closableBlock,
+                                            @NotNull GrClosureSignatureUtil.ArgInfo<PsiElement>[] map,
+                                            @NotNull GroovyResolveResult result) {
+    final PsiElement element = result.getElement();
+    if (element instanceof PsiMethod) {
+      final PsiParameter[] parameters = ((PsiMethod)element).getParameterList().getParameters();
+
+      for (int i = 0; i < map.length; i++) {
+        if (map[i].args.contains(closableBlock)) return parameters[i];
+      }
+    }
+
+    return null;
+  }
+
+  @Nullable
+  private static PsiType inferDelegateType(@NotNull PsiAnnotation delegatesTo, GrClosureSignatureUtil.ArgInfo<PsiElement>[] map) {
+    final PsiAnnotationMemberValue value = delegatesTo.findAttributeValue("value");
+    if (value instanceof GrReferenceExpression) {
+      return extractTypeFromClassType(((GrReferenceExpression)value).getType());
+    }
+    else if (value == null ||
+             value instanceof PsiLiteralExpression && ((PsiLiteralExpression)value).getType() == PsiType.NULL ||
+             value instanceof GrLiteral && ((GrLiteral)value).getType() == PsiType.NULL) {
+      String target = inferStringAttribute(delegatesTo, "target");
+      if (target == null) return null;
+
+      final int parameter = findTargetParameter(delegatesTo, target);
+      if (parameter >= 0) {
+        return map[parameter].type;
+      }
+    }
+    else if (value instanceof PsiExpression) {
+      return ((PsiExpression)value).getType();
+    }
+    return null;
+  }
+
+  private static int findTargetParameter(@NotNull PsiAnnotation delegatesTo, @NotNull String target) {
+    //                                                 ann      mod.list    parameter   param.list
+    final PsiParameterList list = (PsiParameterList)delegatesTo.getParent().getParent().getParent();
+
+    PsiParameter[] parameters = list.getParameters();
+    for (int i = 0; i < parameters.length; i++) {
+      final PsiModifierList modifierList = parameters[i].getModifierList();
+      if (modifierList == null) continue;
+
+      final PsiAnnotation targetAnnotation = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_DELEGATES_TO_TARGET);
+      if (targetAnnotation == null) continue;
+
+      final String value = inferStringAttribute(targetAnnotation, "value");
+      if (value == null) continue;
+
+      if (value.equals(target)) return i;
+    }
+
+    return -1;
+  }
+
+  @Nullable
+  private static String inferStringAttribute(@NotNull PsiAnnotation annotation, @NotNull String attributeName) {
+    final PsiAnnotationMemberValue targetValue = annotation.findAttributeValue(attributeName);
+    if (targetValue instanceof PsiLiteral) {
+      final Object value = ((PsiLiteral)targetValue).getValue();
+      if (value instanceof String) return (String)value;
+    }
+
+    return null;
+  }
+
+  @Nullable
+  private static GrExpression inferCallQualifier(@NotNull GrMethodCall call) {
+    final GrExpression expression = call.getInvokedExpression();
+    if (!(expression instanceof GrReferenceExpression)) return null;
+    return ((GrReferenceExpression)expression).getQualifier();
+  }
+
+  @NotNull
+  private static GroovyResolveResult resolveCall(@NotNull GrCall call) {
+    GroovyResolveResult result = GroovyResolveResult.EMPTY_RESULT;
+
+    if (call instanceof GrMethodCall) {
+      final GrExpression invoked = ((GrMethodCall)call).getInvokedExpression();
+      if (invoked instanceof GrReferenceExpression) {
+        final GroovyResolveResult[] results = ((GrReferenceExpression)invoked).resolveByShape();
+        if (results.length == 1) {
+          result = results[0];
+        }
+      }
+    }
+    else {
+      result = call.advancedResolve();
+    }
+    return result;
+  }
+
+  @Nullable
+  private static PsiType extractTypeFromClassType(@Nullable PsiType type) {
+    if (type instanceof PsiClassType) {
+      final PsiClass resolved = ((PsiClassType)type).resolve();
+      if (resolved != null && CommonClassNames.JAVA_LANG_CLASS.equals(resolved.getQualifiedName())) {
+        final PsiType[] parameters = ((PsiClassType)type).getParameters();
+        if (parameters.length == 1) {
+          return parameters[0];
+        }
+      }
+    }
+    return null;
+  }
+
+  private static int getStrategyValue(@Nullable PsiAnnotationMemberValue strategy) {
+    if (strategy == null) return -1;
+
+    final String text = strategy.getText();
+    if ("0".equals(text)) return 0;
+    if ("1".equals(text)) return 1;
+    if ("2".equals(text)) return 2;
+    if ("3".equals(text)) return 3;
+    if ("4".equals(text)) return 4;
+
+    if (text.endsWith("OWNER_FIRST")) return Closure.OWNER_FIRST;
+    if (text.endsWith("DELEGATE_FIRST")) return Closure.DELEGATE_FIRST;
+    if (text.endsWith("OWNER_ONLY")) return Closure.OWNER_ONLY;
+    if (text.endsWith("DELEGATE_ONLY")) return Closure.DELEGATE_ONLY;
+    if (text.endsWith("TO_SELF")) return Closure.TO_SELF;
+
+    return -1;
+  }
+
+  @Nullable
+  static GrCall getContainingCall(@NotNull GrClosableBlock closableBlock) {
+    final PsiElement parent = closableBlock.getParent();
+    if (parent instanceof GrCall && ArrayUtil.contains(closableBlock, ((GrCall)parent).getClosureArguments())) {
+      return (GrCall)parent;
+    }
+    else if (parent instanceof GrArgumentList) {
+      final PsiElement parent1 = parent.getParent();
+      if (parent1 instanceof GrCall) {
+        return (GrCall)parent1;
+      }
+    }
+
+    return null;
+  }
+
+  public static class DelegatesToInfo {
+    final PsiType myClassToDelegate;
+    final int myStrategy;
+
+    private DelegatesToInfo(@Nullable PsiType classToDelegate, int strategy) {
+      myClassToDelegate = classToDelegate;
+      myStrategy = strategy;
+    }
+
+    public PsiType getTypeToDelegate() {
+      return myClassToDelegate;
+    }
+
+    public int getStrategy() {
+      return myStrategy;
+    }
+  }
+}
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GdkMethodUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GdkMethodUtil.java
index 38b584fcd5bd..d9afcc97c48f 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GdkMethodUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GdkMethodUtil.java
@@ -32,6 +32,7 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrStatement;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
@@ -134,21 +135,6 @@ public class GdkMethodUtil {
     return categoryClass.processDeclarations(delegate, state, null, place);
   }
 
-  public static boolean withIteration(GrClosableBlock block, final PsiScopeProcessor processor) {
-    GrMethodCall call = checkMethodCall(block, WITH);
-    if (call == null) {
-      call = checkMethodCall(block, IDENTITY);
-    }
-    if (call == null) return true;
-    final GrExpression invoked = call.getInvokedExpression();
-    LOG.assertTrue(invoked instanceof GrReferenceExpression);
-    final GrExpression qualifier = ((GrReferenceExpression)invoked).getQualifier();
-    if (qualifier == null) return true;
-    if (!GrReferenceResolveUtil.processQualifier(processor, qualifier, (GrReferenceExpression)invoked)) return false;
-
-    return true;
-  }
-
   @Nullable
   private static GrMethodCall checkMethodCall(GrClosableBlock place, String methodName) {
     final PsiElement context = place.getContext();
@@ -408,4 +394,21 @@ public class GdkMethodUtil {
       }
     });
   }
+
+  public static boolean isWithOrIdentity(@NotNull GroovyResolveResult result) {
+    PsiElement element = result.getElement();
+
+    if (element instanceof PsiMethod && isWithName(((PsiMethod)element).getName())) {
+      if (element instanceof GrGdkMethod) {
+        element = ((GrGdkMethod)element).getStaticMethod();
+      }
+      final PsiClass containingClass = ((PsiMethod)element).getContainingClass();
+      if (containingClass != null) {
+        if (GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(containingClass.getQualifiedName())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
 }
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
index f30b6ea8353d..6466f7ddd514 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/GroovyCommonClassNames.java
@@ -62,6 +62,7 @@ public final class GroovyCommonClassNames {
   @NonNls public static final String GROOVY_TRANSFORM_ANNOTATION_COLLECTOR = "groovy.transform.AnnotationCollector";
   @NonNls public static final String GROOVY_LANG_NEWIFY = "groovy.lang.Newify";
   @NonNls public static final String GROOVY_LANG_DELEGATES_TO = "groovy.lang.DelegatesTo";
+  @NonNls public static final String GROOVY_LANG_DELEGATES_TO_TARGET = "groovy.lang.DelegatesTo.Target";
 
 
   private GroovyCommonClassNames() {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
index 16719cae080d..786aa5595ba4 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
@@ -183,7 +183,6 @@ public class ResolveUtil {
       if (superClass != null && !superClass.processDeclarations(processor, ResolveState.initial(), null, place)) return false;
 
       if (!GdkMethodUtil.categoryIteration((GrClosableBlock)scope, processor, ResolveState.initial())) return false;
-      if (!GdkMethodUtil.withIteration((GrClosableBlock)scope, processor)) return false;
     }
 
     if (scope instanceof GrStatementOwner) {
@@ -452,7 +451,7 @@ public class ResolveUtil {
         if (inCodeBlock && !GdkMethodUtil.categoryIteration((GrClosableBlock)run, processor, state)) return false;
 
         PsiClass superClass = getLiteralSuperClass((GrClosableBlock)run);
-        if (superClass != null && !GdkMethodUtil.processCategoryMethods(((GrClosableBlock)run), processor, state, superClass)) return false;
+        if (superClass != null && !GdkMethodUtil.processCategoryMethods(run, processor, state, superClass)) return false;
       }
 
       if (gpp && run instanceof GrTypeDefinition) {
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy
index 866083ba9fa9..723b9c41c9dd 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/resolve/ResolveWithDelegatesToTest.groovy
@@ -123,7 +123,139 @@ class ResolveWithDelegatesToTest extends LightGroovyTestCase {
         ''', 'Xml'
   }
 
+  void testEmbeddedWithAndShadowing() {
+    assertScript '''
+            class A {
+                int foo() { 1 }
+            }
+            class B {
+                int foo() { 2 }
+            }
+            def a = new A()
+            def b = new B()
+            int result
+            a.with {
+                b.with {
+                    result = fo<caret>o()
+                }
+            }
+            assert result == 2
+        ''', 'B'
+  }
 
+  void testEmbeddedWithAndShadowing2() {
+    assertScript '''
+            class A {
+                int foo() { 1 }
+            }
+            class B {
+                int foo() { 2 }
+            }
+            def a = new A()
+            def b = new B()
+            int result
+            b.with {
+                a.with {
+                    result = fo<caret>o()
+                }
+            }
+            assert result == 1
+        ''', 'A'
+  }
+
+  void testEmbeddedWithAndShadowing3() {
+    assertScript '''
+            class A {
+                int foo() { 1 }
+            }
+            class B {
+                int foo() { 2 }
+            }
+            class C {
+                int foo() { 3 }
+                void test() {
+                    def a = new A()
+                    def b = new B()
+                    int result
+                    b.with {
+                        a.with {
+                            result = fo<caret>o()
+                        }
+                    }
+                    assert result == 1
+                }
+            }
+            new C().test()
+        ''', 'A'
+  }
+
+  void testEmbeddedWithAndShadowing4() {
+    assertScript '''
+            class A {
+                int foo() { 1 }
+            }
+            class B {
+                int foo() { 2 }
+            }
+            class C {
+                int foo() { 3 }
+                void test() {
+                    def a = new A()
+                    def b = new B()
+                    int result
+                    b.with {
+                        a.with {
+                            result = this.f<caret>oo()
+                        }
+                    }
+                    assert result == 3
+                }
+            }
+            new C().test()
+        ''', 'C'
+  }
+
+  void testShouldDelegateToParameter() {
+    assertScript '''
+        class Foo {
+            boolean called = false
+            def foo() { called = true }
+        }
+
+        def with(@DelegatesTo.Target Object target, @DelegatesTo Closure arg) {
+            arg.delegate = target
+            arg()
+        }
+
+        def test() {
+            def obj = new Foo()
+            with(obj) { fo<caret>o() }
+            assert obj.called
+        }
+        test()
+        ''', 'Foo'
+  }
+
+  void testShouldDelegateToParameterUsingExplicitId() {
+    assertScript '''
+        class Foo {
+            boolean called = false
+            def foo() { called = true }
+        }
+
+        def with(@DelegatesTo.Target('target') Object target, @DelegatesTo(target='target') Closure arg) {
+            arg.delegate = target
+            arg()
+        }
+
+        def test() {
+            def obj = new Foo()
+            with(obj) { f<caret>oo() }
+            assert obj.called
+        }
+        test()
+        ''', 'Foo'
+  }
 
   void testInConstructor() {
     assertScript '''
@@ -140,6 +272,54 @@ class ResolveWithDelegatesToTest extends LightGroovyTestCase {
 ''', 'Foo'
   }
 
+  void testNamedArgs() {
+    addLinkedHashMap()
+    assertScript '''
+def with(@DelegatesTo.Target Object target, @DelegatesTo(strategy = Closure.DELEGATE_FIRST) Closure arg) {
+    for (Closure a : arg) {
+        a.delegate = target
+        a.resolveStrategy = Closure.DELEGATE_FIRST
+        a()
+    }
+}
+
+@CompileStatic
+def test() {
+    with(a:2) {
+        print(g<caret>et('a'))
+    }
+}
+
+test()
+''', 'HashMap'
+  }
+
+  void testEllipsisArgs() {
+    addLinkedHashMap()
+
+    assertScript '''
+def with(@DelegatesTo.Target Object target, @DelegatesTo(strategy = Closure.DELEGATE_FIRST) Closure... arg) {
+    for (Closure a : arg) {
+        a.delegate = target
+        a.resolveStrategy = Closure.DELEGATE_FIRST
+        a()
+    }
+}
+
+@CompileStatic
+def test() {
+    with(a:2, {
+        print(get('a'))
+    }, {
+        print(g<caret>et('a'))
+    } )
+}
+
+test()
+
+''', 'HashMap'
+  }
+
   void assertScript(String text, String resolvedClass) {
     myFixture.configureByText('_a.groovy', text)
 

From e518fc39e498e3e36c1ff6e9d81c2ef04bb7eb7a Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Tue, 26 Feb 2013 13:55:56 +0400
Subject: [PATCH 173/354] IDEA-99587 fix resolve & testdata

---
 .../groovy/annotator/GroovyAnnotator.java     |  2 +-
 .../blocks/GrClosableBlockImpl.java           | 34 ++++++++++---------
 .../lang/resolve/DeclarationCacheKey.java     | 19 +++++++----
 .../groovy/lang/resolve/ResolveUtil.java      | 13 +++----
 .../codeBlock/anonymousFromMap.java           |  2 +-
 .../codeBlock/closure.java                    |  2 +-
 .../methodParamInClosureImplicitReturn.java   |  4 +--
 .../file/refInClosureInScript.java            |  2 +-
 8 files changed, 43 insertions(+), 35 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
index bc09365a7ce3..a1ec3e409b5a 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
@@ -636,7 +636,7 @@ public class GroovyAnnotator extends GroovyElementVisitor implements Annotator {
           @SuppressWarnings({"ConstantConditions"})
           final PsiElement context = variable.getContext().getContext();
           if (context instanceof GrClosableBlock) {
-            duplicate = ResolveUtil.resolveExistingElement((GroovyPsiElement)context, new DuplicateVariablesProcessor(variable),
+            duplicate = ResolveUtil.resolveExistingElement((GroovyPsiElement)context.getParent(), new DuplicateVariablesProcessor(variable),
                                                            GrVariable.class, GrReferenceExpression.class);
           }
           else if (context instanceof GrMethod && !(context.getParent() instanceof GroovyFile)) {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
index 4981b0732ab2..a6c1799efc07 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrClosableBlockImpl.java
@@ -87,8 +87,8 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     if (!super.processDeclarations(processor, _state, lastParent, place)) return false;
     if (!processParameters(processor, _state, state, place)) return false;
     if (!ResolveUtil.processElement(processor, getOwner(), _state)) return false;
-    if (!processOwnerAndDelegate(processor, state, place)) return false;
     if (!processClosureClassMembers(processor, state, lastParent, place)) return false;
+    if (!processOwnerAndDelegate(processor, state, place)) return false;
 
     return true;
   }
@@ -97,7 +97,7 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     Boolean result = processDelegatesTo(processor, state, place);
     if (result != null) return result.booleanValue();
 
-    if (!processOwner(processor, state)) return false;
+    if (!processOwner(processor, state, place)) return false;
     return true;
   }
 
@@ -110,15 +110,15 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
 
     switch (info.getStrategy()) {
       case Closure.OWNER_FIRST:
-        if (!processOwner(processor, state)) return false;
+        if (!processOwner(processor, state, place)) return false;
         if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
         return true;
       case Closure.DELEGATE_FIRST:
         if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
-        if (!processOwner(processor, state)) return false;
+        if (!processOwner(processor, state, place)) return false;
         return true;
       case Closure.OWNER_ONLY:
-        if (!processOwner(processor, state)) return false;
+        if (!processOwner(processor, state, place)) return false;
         return true;
       case Closure.DELEGATE_ONLY:
         if (!processDelegate(processor, state, place, info.getTypeToDelegate())) return false;
@@ -130,11 +130,14 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     }
   }
 
-  private static boolean processDelegate(@NotNull PsiScopeProcessor processor,
-                                         @NotNull ResolveState state,
-                                         @NotNull PsiElement place,
-                                         @Nullable final PsiType classToDelegate) {
+  private boolean processDelegate(@NotNull PsiScopeProcessor processor,
+                                  @NotNull ResolveState state,
+                                  @NotNull PsiElement place,
+                                  @Nullable final PsiType classToDelegate) {
     if (classToDelegate != null) {
+      if (state.get(ResolverProcessor.RESOLVE_CONTEXT) == null) {
+        state = state.put(ResolverProcessor.RESOLVE_CONTEXT, this);
+      }
       return ResolveUtil.processAllDeclarations(classToDelegate, processor, state, place);
     }
 
@@ -177,14 +180,13 @@ public class GrClosableBlockImpl extends GrBlockImpl implements GrClosableBlock
     return true;
   }
 
-  private boolean processOwner(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state) {
-    final PsiElement parent = this.getParent();
-    if (parent instanceof GroovyPsiElement) {
-      return ResolveUtil.treeWalkUp((GroovyPsiElement)parent, processor, true, state);
-    }
-    else {
-      return true;
+  private boolean processOwner(@NotNull PsiScopeProcessor processor,
+                               @NotNull ResolveState state,
+                               @NotNull PsiElement place) {
+    if (state.get(ResolverProcessor.RESOLVE_CONTEXT) == null) {
+      state = state.put(ResolverProcessor.RESOLVE_CONTEXT, this);
     }
+    return ResolveUtil.treeWalkUp(getParent(), place, processor, true, state);
   }
 
   private boolean isItAlreadyDeclared(@Nullable PsiElement place) {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
index 8c17a19a3acf..55a9e7af8be7 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/DeclarationCacheKey.java
@@ -28,7 +28,6 @@ import com.intellij.util.PairProcessor;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ClassHint;
 import org.jetbrains.plugins.groovy.lang.resolve.processors.ResolverProcessor;
@@ -54,11 +53,13 @@ class DeclarationCacheKey {
   @Nullable private final String name;
   @NotNull private final EnumSet<ClassHint.ResolveKind> kinds;
   private final boolean nonCode;
+  @NotNull private final PsiElement place;
 
-  DeclarationCacheKey(@Nullable String name, ClassHint hint, boolean nonCode) {
+  DeclarationCacheKey(@Nullable String name, ClassHint hint, boolean nonCode, @NotNull PsiElement place) {
     this.name = name;
     this.kinds = getResolveKinds(hint);
     this.nonCode = nonCode;
+    this.place = place;
   }
 
   private static EnumSet<ClassHint.ResolveKind> getResolveKinds(ClassHint hint) {
@@ -93,6 +94,8 @@ class DeclarationCacheKey {
       return false;
     }
 
+    if (place != key.place) return false;
+
     return true;
   }
 
@@ -101,6 +104,7 @@ class DeclarationCacheKey {
     int result = name != null ? name.hashCode() : 0;
     result = 31 * result + kinds.hashCode();
     result = 31 * result + (nonCode ? 1 : 0);
+    result = 31* result + place.hashCode();
     return result;
   }
 
@@ -110,15 +114,16 @@ class DeclarationCacheKey {
            "name='" + name + '\'' +
            ", kinds=" + kinds +
            ", nonCode=" + nonCode +
+           ", place=" + place.toString() +
            '}';
   }
 
-  private List<DeclarationHolder> collectDeclarations(final GroovyPsiElement place) {
+  private List<DeclarationHolder> collectDeclarations(final PsiElement place) {
     final ArrayList<DeclarationHolder> result = new ArrayList<DeclarationHolder>();
     PsiTreeUtil.treeWalkUp(place, null, new PairProcessor<PsiElement, PsiElement>() {
       @Override
       public boolean process(PsiElement scope, PsiElement lastParent) {
-        result.add(collectScopeDeclarations(scope, lastParent, place));
+        result.add(collectScopeDeclarations(scope, lastParent));
         if (scope instanceof GrClosableBlock) return false; //closures tree walk up themselves
         return true;
       }
@@ -126,14 +131,14 @@ class DeclarationCacheKey {
     return result;
   }
 
-  private DeclarationHolder collectScopeDeclarations(PsiElement scope, PsiElement lastParent, GroovyPsiElement place) {
+  private DeclarationHolder collectScopeDeclarations(PsiElement scope, PsiElement lastParent) {
     MyCollectProcessor plainCollector = new MyCollectProcessor(scope);
     MyCollectProcessor nonCodeCollector = new MyCollectProcessor(scope);
     ResolveUtil.doProcessDeclarations(place, lastParent, scope, plainCollector, nonCode ? nonCodeCollector : null, ResolveState.initial());
     return new DeclarationHolder(scope, plainCollector.declarations, nonCodeCollector.declarations);
   }
 
-  private List<DeclarationHolder> getAllDeclarations(GroovyPsiElement place) {
+  private List<DeclarationHolder> getAllDeclarations(PsiElement place) {
     ConcurrentMap<DeclarationCacheKey, List<DeclarationHolder>> cache =
       CachedValuesManager.getManager(place.getProject()).getCachedValue(place, VALUE_PROVIDER);
     List<DeclarationHolder> declarations = cache.get(this);
@@ -144,7 +149,7 @@ class DeclarationCacheKey {
     return declarations;
   }
 
-  boolean processCachedDeclarations(GroovyPsiElement place, PsiScopeProcessor processor) {
+  boolean processCachedDeclarations(PsiElement place, PsiScopeProcessor processor) {
     for (DeclarationHolder holder : getAllDeclarations(place)) {
       if (!holder.processCachedDeclarations(processor)) {
         return false;
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
index 786aa5595ba4..a9beffbe8a10 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
@@ -95,7 +95,7 @@ public class ResolveUtil {
   public static boolean treeWalkUp(@NotNull final GroovyPsiElement place,
                                    @NotNull final PsiScopeProcessor processor,
                                    boolean processNonCodeMethods) {
-    return treeWalkUp(place, processor, processNonCodeMethods, ResolveState.initial());
+    return treeWalkUp(place, place, processor, processNonCodeMethods, ResolveState.initial());
   }
 
   /**
@@ -106,20 +106,21 @@ public class ResolveUtil {
    * @param state
    * @return
    */
-  public static boolean treeWalkUp(@NotNull final GroovyPsiElement place,
+  public static boolean treeWalkUp(@NotNull final PsiElement place,
+                                   @NotNull final PsiElement originalPlace,
                                    @NotNull final PsiScopeProcessor processor,
                                    boolean processNonCodeMethods,
                                    @NotNull final ResolveState state) {
     ClassHint hint = processor.getHint(ClassHint.KEY);
     if (hint != null) {
-      return new DeclarationCacheKey(getNameHint(processor), hint, processNonCodeMethods).processCachedDeclarations(place, processor);
+      return new DeclarationCacheKey(getNameHint(processor), hint, processNonCodeMethods, originalPlace).processCachedDeclarations(place, processor);
     }
 
     final PsiScopeProcessor nonCodeProcessor = processNonCodeMethods ? processor : null;
     return PsiTreeUtil.treeWalkUp(place, null, new PairProcessor<PsiElement, PsiElement>() {
       @Override
       public boolean process(PsiElement scope, PsiElement lastParent) {
-        if (!doProcessDeclarations(place, lastParent, scope, substituteProcessor(processor, scope), nonCodeProcessor, state)) {
+        if (!doProcessDeclarations(originalPlace, lastParent, scope, substituteProcessor(processor, scope), nonCodeProcessor, state)) {
           return false;
         }
         if (scope instanceof GrClosableBlock) return false; //closures tree walk up themselves
@@ -129,7 +130,7 @@ public class ResolveUtil {
     });
   }
 
-  static boolean doProcessDeclarations(@NotNull GroovyPsiElement place,
+  static boolean doProcessDeclarations(@NotNull PsiElement place,
                                        @Nullable PsiElement lastParent,
                                        @NotNull PsiElement scope,
                                        @NotNull PsiScopeProcessor plainProcessor,
@@ -158,7 +159,7 @@ public class ResolveUtil {
     return processor;
   }
 
-  static boolean processScopeNonCodeMethods(GroovyPsiElement place, PsiElement lastParent, PsiScopeProcessor processor, PsiElement scope) {
+  static boolean processScopeNonCodeMethods(PsiElement place, PsiElement lastParent, PsiScopeProcessor processor, PsiElement scope) {
     if (scope instanceof GrTypeDefinition) {
       if (!processNonCodeMembers(createPsiType((GrTypeDefinition)scope), processor, place, ResolveState.initial())) return false;
 
diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/anonymousFromMap.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/anonymousFromMap.java
index d656375ed55f..1cb3b2258ab6 100644
--- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/anonymousFromMap.java
+++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/anonymousFromMap.java
@@ -1,5 +1,5 @@
 print(new java.lang.Runnable() {
-public void run(java.lang.Object it) {org.codehaus.groovy.runtime.DefaultGroovyMethods.print(anonymousFromMap.this, "foo}");}
+public void run(java.lang.Object it) {print("foo}");}
 public void run() {
 this.run(null);
 }
diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java
index 15d0b91c2466..4b7cb1b3b6c4 100644
--- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java
+++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/codeBlock/closure.java
@@ -1,7 +1,7 @@
 java.util.ArrayList<java.lang.Integer> list = new java.util.ArrayList<java.lang.Integer>(java.util.Arrays.asList(1, 2, 3));
 org.codehaus.groovy.runtime.DefaultGroovyMethods.each(list, new groovy.lang.Closure<java.lang.Void>(this, this) {
 public void doCall(java.lang.Object it) {
-org.codehaus.groovy.runtime.DefaultGroovyMethods.print(closure.this, it);
+print(it);
 }
 
 public void doCall() {
diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java
index 201a3785f2b0..22d7b56914b2 100644
--- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java
+++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/methodParamInClosureImplicitReturn.java
@@ -13,7 +13,7 @@ public void foo(int x) {final groovy.lang.Reference<java.lang.Integer> i = new g
 
 org.codehaus.groovy.runtime.DefaultGroovyMethods.each(new java.util.ArrayList<java.lang.Integer>(java.util.Arrays.asList(1, 2, 3)), new groovy.lang.Closure<java.lang.Integer>(this, this) {
 public java.lang.Integer doCall(java.lang.Object it) {
-org.codehaus.groovy.runtime.DefaultGroovyMethods.print(methodParamInClosureImplicitReturn.this, i.get());
+print(i.get());
 return setGroovyRef(i, i.get() + 1);
 }
 
@@ -25,7 +25,7 @@ return doCall(null);
 
 org.codehaus.groovy.runtime.DefaultGroovyMethods.each(new java.util.ArrayList<java.lang.Integer>(java.util.Arrays.asList(1, 2, 3)), new groovy.lang.Closure<java.lang.Integer>(this, this) {
 public java.lang.Integer doCall(java.lang.Object it) {
-org.codehaus.groovy.runtime.DefaultGroovyMethods.print(methodParamInClosureImplicitReturn.this, i.get());
+print(i.get());
 i.set(i.get()++);
 return i.get();
 }
diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java
index 8c2d245862ec..f2960f8113f4 100644
--- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java
+++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/refInClosureInScript.java
@@ -12,7 +12,7 @@ foo.set(foo.get()++);
 foo.set(foo.get() + 2);
 foo.set(foo.get() - 1);
 foo.set(4);
-org.codehaus.groovy.runtime.DefaultGroovyMethods.print(refInClosureInScript.this, foo.get());
+print(foo.get());
 }
 
 public void doCall() {

From b6a7134b3d6bb4a1dcb4f854ec711cc1843a056d Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 11:01:14 +0100
Subject: [PATCH 174/354] javafx: expand attribute to subtag (IDEA-101706)

---
 .../fxml/JavaFXExpandAttributeTest.java       |  81 +++++++++++++
 .../after.fxml.template                       |   3 +
 .../before.fxml.template                      |   2 +
 .../description.html                          |   6 +
 .../src/META-INF/common-javaFX-plugin.xml     |   4 +
 .../plugins/javaFX/fxml/JavaFxPsiUtil.java    |  33 ++++++
 .../JavaFxExpandAttributeIntention.java       | 108 ++++++++++++++++++
 .../JavaFxClassBackedElementDescriptor.java   |  32 +-----
 .../intentions/expandAttr/defaultAttr.fxml    |   5 +
 .../expandAttr/expandMultipleVals2List.fxml   |   3 +
 .../expandMultipleVals2List_after.fxml        |   9 ++
 .../intentions/expandAttr/expandVal2List.fxml |   3 +
 .../expandAttr/expandVal2List_after.fxml      |   7 ++
 .../intentions/expandAttr/simple.fxml         |   5 +
 .../intentions/expandAttr/simple_after.fxml   |   7 ++
 .../intentions/expandAttr/staticAttr.fxml     |   5 +
 .../expandAttr/staticAttr_after.fxml          |   7 ++
 17 files changed, 291 insertions(+), 29 deletions(-)
 create mode 100644 plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXExpandAttributeTest.java
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/after.fxml.template
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/before.fxml.template
 create mode 100644 plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/description.html
 create mode 100644 plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxExpandAttributeIntention.java
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/defaultAttr.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List_after.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/expandVal2List.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/expandVal2List_after.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/simple.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/simple_after.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/staticAttr.fxml
 create mode 100644 plugins/javaFX/testData/intentions/expandAttr/staticAttr_after.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXExpandAttributeTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXExpandAttributeTest.java
new file mode 100644
index 000000000000..bcee2c97e692
--- /dev/null
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXExpandAttributeTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml;
+
+import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
+import com.intellij.codeInsight.daemon.impl.HighlightInfo;
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.codeInsight.intention.impl.ShowIntentionActionsHandler;
+import com.intellij.openapi.application.PluginPathManager;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.psi.PsiFile;
+import com.intellij.testFramework.PsiTestUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class JavaFXExpandAttributeTest extends DaemonAnalyzerTestCase {
+  @Override
+  protected void setUpModule() {
+    super.setUpModule();
+    PsiTestUtil.addLibrary(getModule(), "javafx", PluginPathManager.getPluginHomePath("javaFX") + "/testData", "jfxrt.jar");
+  }
+
+  public void testDefaultAttr() throws Exception {
+    doTest(false, "fx:id");
+  }
+
+  public void testSimple() throws Exception {
+    doTest(true, "disable");
+  }
+
+  public void testStaticAttr() throws Exception {
+    doTest(true, "GridPane.columnIndex");
+  }
+
+  public void testExpandMultipleVals2List() throws Exception {
+    doTest(true, "stylesheets");
+  }
+
+  public void testExpandVal2List() throws Exception {
+    doTest(true, "stylesheets");
+  }
+
+  private void doTest(boolean available, final String attrName) throws Exception {
+    configureByFiles(null, getTestName(true) + ".fxml");
+    
+    final List<HighlightInfo> infos = doHighlighting();
+    Editor editor = getEditor();
+    PsiFile file = getFile();
+
+    final String actionName = "Expand '" + attrName + "' to tag";
+    IntentionAction intentionAction = findIntentionAction(infos, actionName, editor, file);
+
+    if (available) {
+      assertNotNull(actionName, intentionAction);
+      assertTrue(ShowIntentionActionsHandler.chooseActionAndInvoke(file, editor, intentionAction, actionName));
+      checkResultByFile(getTestName(true) + "_after.fxml");
+    } else {
+      assertNull(intentionAction);
+    }
+  }
+
+  @NotNull
+  @Override
+  protected String getTestDataPath() {
+    return PluginPathManager.getPluginHomePath("javaFX") + "/testData/intentions/expandAttr/";
+  }
+}
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/after.fxml.template b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/after.fxml.template
new file mode 100644
index 000000000000..e1e68e945b24
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/after.fxml.template
@@ -0,0 +1,3 @@
+<Button fx:id="btn">
+    <text>text</text>    
+</Button>
\ No newline at end of file
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/before.fxml.template b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/before.fxml.template
new file mode 100644
index 000000000000..83d368b1ea0f
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/before.fxml.template
@@ -0,0 +1,2 @@
+<Button fx:id="btn" <spot>text="text"</spot> >
+</Button>
\ No newline at end of file
diff --git a/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/description.html b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/description.html
new file mode 100644
index 000000000000..a3598b3ef7b4
--- /dev/null
+++ b/plugins/javaFX/resources/intentionDescriptions/JavaFxExpandAttributeIntention/description.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+This intention expands property attribute to a subtag.
+</body>
+</html>
+    
\ No newline at end of file
diff --git a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
index 4ddebeb1b51d..82c06995b4fe 100644
--- a/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
+++ b/plugins/javaFX/src/META-INF/common-javaFX-plugin.xml
@@ -24,6 +24,10 @@
       <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxCollapseSubTagToAttributeIntention</className>
       <category>JavaFX</category>
     </intentionAction>
+    <intentionAction>
+      <className>org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions.JavaFxExpandAttributeIntention</className>
+      <category>JavaFX</category>
+    </intentionAction>
     <lang.importOptimizer language="XML" implementationClass="org.jetbrains.plugins.javaFX.fxml.codeInsight.JavaFxImportsOptimizer" order="before XML"/>
     <psi.referenceContributor implementation="org.jetbrains.plugins.javaFX.fxml.refs.JavaFxReferencesContributor"/>
   </extensions>
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
index 7ff8934ef9bb..c381600a8a7b 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
@@ -19,12 +19,14 @@ import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.lang.ASTNode;
 import com.intellij.lang.xml.XMLLanguage;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
 import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.searches.ClassInheritorsSearch;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.*;
 import com.intellij.psi.xml.*;
@@ -368,6 +370,37 @@ public class JavaFxPsiUtil {
     return null;
   }
 
+  public static String isAbleToInstantiate(final PsiClass psiClass) {
+    if(psiClass.getConstructors().length > 0) {
+      final Project project = psiClass.getProject();
+      final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
+      final PsiMethod noArgConstructor = psiClass
+        .findMethodBySignature(factory.createConstructor(psiClass.getName()), false);
+      if (noArgConstructor == null) {
+        final PsiMethod valueOf = findValueOfMethod(psiClass);
+        if (valueOf == null) {
+          final PsiClass builderClass = JavaPsiFacade.getInstance(project).findClass(JavaFxCommonClassNames.JAVAFX_FXML_BUILDER,
+                                                                                     GlobalSearchScope.allScope(project));
+          if (builderClass != null) {
+            //todo cache this info
+            final PsiTypeParameter typeParameter = builderClass.getTypeParameters()[0];
+            if (ClassInheritorsSearch.search(builderClass).forEach(new Processor<PsiClass>() {
+              @Override
+              public boolean process(PsiClass aClass) {
+                final PsiType initType =
+                  TypeConversionUtil.getSuperClassSubstitutor(builderClass, aClass, PsiSubstitutor.EMPTY).substitute(typeParameter);
+                return !Comparing.equal(psiClass, PsiUtil.resolveClassInClassTypeOnly(initType));
+              }
+            })) {
+              return "Unable to instantiate";
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+
   private static class JavaFxControllerCachedValueProvider implements CachedValueProvider<PsiClass> {
     private final Project myProject;
     private final PsiFile myContainingFile;
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxExpandAttributeIntention.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxExpandAttributeIntention.java
new file mode 100644
index 000000000000..746537139c3e
--- /dev/null
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/intentions/JavaFxExpandAttributeIntention.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.javaFX.fxml.codeInsight.intentions;
+
+import com.intellij.codeInsight.CodeInsightUtilBase;
+import com.intellij.codeInsight.daemon.impl.analysis.GenericsHighlightUtil;
+import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.*;
+import com.intellij.psi.util.PsiUtil;
+import com.intellij.psi.xml.*;
+import com.intellij.util.Function;
+import com.intellij.util.IncorrectOperationException;
+import com.intellij.xml.XmlAttributeDescriptor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.javaFX.fxml.FxmlConstants;
+import org.jetbrains.plugins.javaFX.fxml.JavaFxPsiUtil;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxDefaultAttributeDescriptor;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxPropertyAttributeDescriptor;
+import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxStaticPropertyAttributeDescriptor;
+
+/**
+ * User: anna
+ * Date: 2/22/13
+ */
+public class JavaFxExpandAttributeIntention extends PsiElementBaseIntentionAction{
+  private static final Logger LOG = Logger.getInstance("#" + JavaFxExpandAttributeIntention.class.getName());
+
+  @Override
+  public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException {
+    if (!CodeInsightUtilBase.preparePsiElementsForWrite(element)) return;
+    final XmlAttribute attr = (XmlAttribute)element.getParent();
+    final String name = attr.getName();
+    final XmlAttributeDescriptor descriptor = attr.getDescriptor();
+    LOG.assertTrue(descriptor != null);
+    String value = attr.getValue();
+    final PsiElement declaration = descriptor.getDeclaration();
+    if (declaration instanceof PsiField) {
+      final PsiType fieldType = ((PsiField)declaration).getType();
+      final PsiType itemType = GenericsHighlightUtil.getCollectionItemType(fieldType, declaration.getResolveScope());
+      if (itemType != null) {
+        final String typeNode = itemType.getPresentableText();
+        JavaFxPsiUtil.insertImportWhenNeeded((XmlFile)attr.getContainingFile(), typeNode, itemType.getCanonicalText());
+        final String[] vals = value.split(",");
+        value = StringUtil.join(vals, new Function<String, String>() {
+          @Override
+          public String fun(String s) {
+            return "<" + typeNode + " " + FxmlConstants.FX_VALUE + "=\"" + s.trim() + "\"/>";
+          }
+        }, "\n");
+      }
+    }
+    final XmlTag childTag = XmlElementFactory.getInstance(project).createTagFromText("<" + name + ">" + value + "</" + name + ">");
+    attr.getParent().add(childTag);
+    attr.delete();
+  }
+
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
+    if (element instanceof XmlToken && ((XmlToken)element).getTokenType() == XmlTokenType.XML_NAME) {
+      final PsiElement parent = element.getParent();
+      if (parent instanceof XmlAttribute) {
+        final XmlAttributeDescriptor descriptor = ((XmlAttribute)parent).getDescriptor();
+        if (descriptor instanceof JavaFxPropertyAttributeDescriptor && !(descriptor instanceof JavaFxDefaultAttributeDescriptor)) {
+          
+          PsiType tagType = null;
+          final PsiElement declaration = descriptor.getDeclaration();
+          if (declaration instanceof PsiField) {
+            tagType = ((PsiField)declaration).getType();
+          } else if (declaration instanceof PsiMethod) {
+            final PsiParameter[] parameters = ((PsiMethod)declaration).getParameterList().getParameters();
+            if (parameters.length == 1) {
+              tagType = parameters[0].getType();
+            }
+          }
+          PsiClass tagClass = PsiUtil.resolveClassInType(tagType instanceof PsiPrimitiveType ? ((PsiPrimitiveType)tagType).getBoxedType(parent) : tagType);
+          if ((tagClass != null && JavaFxPsiUtil.isAbleToInstantiate(tagClass) == null) || descriptor instanceof JavaFxStaticPropertyAttributeDescriptor) {
+            setText("Expand '" + ((XmlAttribute)parent).getName() + "' to tag");
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  @NotNull
+  @Override
+  public String getFamilyName() {
+    return "Expand attribute to tag";
+  }
+}
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
index e450e00cbb5b..1c7bf1b57305 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxClassBackedElementDescriptor.java
@@ -9,16 +9,13 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.xml.XmlAttributeImpl;
 import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.searches.ClassInheritorsSearch;
 import com.intellij.psi.util.InheritanceUtil;
 import com.intellij.psi.util.PropertyUtil;
 import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.psi.xml.XmlAttribute;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.Function;
-import com.intellij.util.Processor;
 import com.intellij.xml.XmlAttributeDescriptor;
 import com.intellij.xml.XmlElementDescriptor;
 import com.intellij.xml.XmlElementsGroup;
@@ -283,32 +280,9 @@ public class JavaFxClassBackedElementDescriptor implements XmlElementDescriptor,
     }
     validateTagAccordingToFieldType(context, parentTag, host);
     if (myPsiClass != null && myPsiClass.isValid()) {
-      if(myPsiClass.getConstructors().length > 0) {
-        final Project project = myPsiClass.getProject();
-        final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
-        final PsiMethod noArgConstructor = myPsiClass
-          .findMethodBySignature(factory.createConstructor(myPsiClass.getName()), false);
-        if (noArgConstructor == null) {
-          final PsiMethod valueOf = JavaFxPsiUtil.findValueOfMethod(myPsiClass);
-          if (valueOf == null) {
-            final PsiClass builderClass = JavaPsiFacade.getInstance(project).findClass(JavaFxCommonClassNames.JAVAFX_FXML_BUILDER,
-                                                                                       GlobalSearchScope.allScope(project));
-            if (builderClass != null) {
-              //todo cache this info
-              final PsiTypeParameter typeParameter = builderClass.getTypeParameters()[0];
-              if (ClassInheritorsSearch.search(builderClass).forEach(new Processor<PsiClass>() {
-                @Override
-                public boolean process(PsiClass aClass) {
-                  final PsiType initType =
-                    TypeConversionUtil.getSuperClassSubstitutor(builderClass, aClass, PsiSubstitutor.EMPTY).substitute(typeParameter);
-                  return !Comparing.equal(myPsiClass, PsiUtil.resolveClassInClassTypeOnly(initType));
-                }
-              })) {
-                host.addMessage(context, "Unable to instantiate", ValidationHost.ErrorType.ERROR);
-              }
-            }
-          }
-        }
+      final String message = JavaFxPsiUtil.isAbleToInstantiate(myPsiClass);
+      if (message != null) {
+        host.addMessage(context, message, ValidationHost.ErrorType.ERROR);
       }
     }
   }
diff --git a/plugins/javaFX/testData/intentions/expandAttr/defaultAttr.fxml b/plugins/javaFX/testData/intentions/expandAttr/defaultAttr.fxml
new file mode 100644
index 000000000000..1baa6f27b5a8
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/defaultAttr.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Label fx:i<caret>d="myLabel"/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List.fxml b/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List.fxml
new file mode 100644
index 000000000000..1e2ae72c668e
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List.fxml
@@ -0,0 +1,3 @@
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml" stylesh<caret>eets="style1.css,style2.css,style3.css">
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List_after.fxml b/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List_after.fxml
new file mode 100644
index 000000000000..d652e5bb0d22
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/expandMultipleVals2List_after.fxml
@@ -0,0 +1,9 @@
+<?import javafx.scene.layout.GridPane?>
+<?import java.lang.String?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <stylesheets>
+        <String fx:value="style1.css"/>
+        <String fx:value="style2.css"/>
+        <String fx:value="style3.css"/>
+    </stylesheets>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/expandVal2List.fxml b/plugins/javaFX/testData/intentions/expandAttr/expandVal2List.fxml
new file mode 100644
index 000000000000..5e8b423a4715
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/expandVal2List.fxml
@@ -0,0 +1,3 @@
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml" stylesh<caret>eets="style1.css">
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/expandVal2List_after.fxml b/plugins/javaFX/testData/intentions/expandAttr/expandVal2List_after.fxml
new file mode 100644
index 000000000000..469b594bcd70
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/expandVal2List_after.fxml
@@ -0,0 +1,7 @@
+<?import javafx.scene.layout.GridPane?>
+<?import java.lang.String?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <stylesheets>
+        <String fx:value="style1.css"/>
+    </stylesheets>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/simple.fxml b/plugins/javaFX/testData/intentions/expandAttr/simple.fxml
new file mode 100644
index 000000000000..e845445d6eb5
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/simple.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button onAction="#sayHelloWorld" disa<caret>ble="false"/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/simple_after.fxml b/plugins/javaFX/testData/intentions/expandAttr/simple_after.fxml
new file mode 100644
index 000000000000..62c300369668
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/simple_after.fxml
@@ -0,0 +1,7 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Button onAction="#sayHelloWorld">
+        <disable>false</disable>
+    </Button>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/staticAttr.fxml b/plugins/javaFX/testData/intentions/expandAttr/staticAttr.fxml
new file mode 100644
index 000000000000..47c8cb8bc8ae
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/staticAttr.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Label fx:id="myLabel" GridPane.co<caret>lumnIndex="1"/>
+</GridPane>
\ No newline at end of file
diff --git a/plugins/javaFX/testData/intentions/expandAttr/staticAttr_after.fxml b/plugins/javaFX/testData/intentions/expandAttr/staticAttr_after.fxml
new file mode 100644
index 000000000000..877364ced9ff
--- /dev/null
+++ b/plugins/javaFX/testData/intentions/expandAttr/staticAttr_after.fxml
@@ -0,0 +1,7 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml">
+    <Label fx:id="myLabel">
+        <GridPane.columnIndex>1</GridPane.columnIndex>
+    </Label>
+</GridPane>
\ No newline at end of file

From 385c51292f044fd534d05d09ec365cae91f2e097 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Tue, 26 Feb 2013 14:04:21 +0400
Subject: [PATCH 175/354] IDEA-101810 Settings | Gradle: input fields are
 misaligned

---
 .../org/jetbrains/plugins/gradle/config/GradleConfigurable.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
index eff3351ed109..3e9556c710c7 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleConfigurable.java
@@ -200,6 +200,8 @@ public class GradleConfigurable implements SearchableConfigurable, Configurable.
     myComponent.add(myGradleHomeLabel, pathLabelConstraints);
     myComponent.add(myGradleHomePathField, fillLineConstraints);
 
+    pathLabelConstraints.insets(5, 0, 0, 0);
+    fillLineConstraints.insets(5, 0, 0, 0);
     myComponent.add(myServiceDirectoryLabel, pathLabelConstraints);
     myComponent.add(myServiceDirectoryPathField, fillLineConstraints);
 

From fc7a588b1b7e8b5547880164ef58c8820b94576c Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Tue, 26 Feb 2013 14:18:11 +0400
Subject: [PATCH 176/354] WEB-6741 Emmet, html: item numbering in tag name not
 rendered

---
 .../template/emmet/EmmetParser.java           |  2 +-
 .../template/emmet/XmlEmmetParser.java        |  5 +--
 .../template/emmet/nodes/TemplateNode.java    | 33 ++++++++++++++++---
 3 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetParser.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetParser.java
index 3c89772773fb..c5224aee4b96 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetParser.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/EmmetParser.java
@@ -32,7 +32,7 @@ import java.util.List;
 public abstract class EmmetParser {
   private final List<ZenCodingToken> myTokens;
   protected final CustomTemplateCallback myCallback;
-  private final ZenCodingGenerator myGenerator;
+  protected final ZenCodingGenerator myGenerator;
 
   private int myIndex = 0;
 
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
index e0935b7acfb7..25d7ddd9c673 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
@@ -22,6 +22,7 @@ import com.intellij.codeInsight.template.emmet.nodes.*;
 import com.intellij.codeInsight.template.emmet.tokens.*;
 import com.intellij.codeInsight.template.impl.TemplateImpl;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.xml.XmlTag;
@@ -126,7 +127,7 @@ public class XmlEmmetParser extends EmmetParser {
     }
 
     TemplateImpl template = myCallback.findApplicableTemplate(templateKey);
-    if (template == null && !ZenCodingUtil.isXML11ValidQName(templateKey)) {
+    if (template == null && !ZenCodingUtil.isXML11ValidQName(templateKey) && !StringUtil.containsChar(templateKey, '$')) {
       return null;
     }
 
@@ -139,7 +140,7 @@ public class XmlEmmetParser extends EmmetParser {
     if (!setTemplate(templateToken, template)) {
       return null;
     }
-    return new TemplateNode(templateToken);
+    return new TemplateNode(templateToken, myGenerator);
   }
 
   @Override
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/nodes/TemplateNode.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/nodes/TemplateNode.java
index 317459e11999..25cccee7b969 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/nodes/TemplateNode.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/nodes/TemplateNode.java
@@ -17,9 +17,14 @@ package com.intellij.codeInsight.template.emmet.nodes;
 
 import com.google.common.base.Joiner;
 import com.intellij.codeInsight.template.CustomTemplateCallback;
+import com.intellij.codeInsight.template.emmet.ZenCodingUtil;
+import com.intellij.codeInsight.template.emmet.generators.ZenCodingGenerator;
 import com.intellij.codeInsight.template.emmet.tokens.TemplateToken;
+import com.intellij.codeInsight.template.impl.TemplateImpl;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Arrays;
 import java.util.List;
@@ -30,9 +35,15 @@ import java.util.List;
 public class TemplateNode extends ZenCodingNode {
   private static final Joiner JOINER = Joiner.on(",");
   private final TemplateToken myTemplateToken;
+  @Nullable private final ZenCodingGenerator myGenerator;
 
   public TemplateNode(TemplateToken templateToken) {
-    myTemplateToken = templateToken;
+    this(templateToken, null);
+  }
+
+  public TemplateNode(TemplateToken token, @Nullable ZenCodingGenerator generator) {
+    myTemplateToken = token;
+    myGenerator = generator;
   }
 
   public TemplateToken getTemplateToken() {
@@ -45,11 +56,25 @@ public class TemplateNode extends ZenCodingNode {
                                      int totalIterations, String surroundedText,
                                      CustomTemplateCallback callback,
                                      boolean insertSurroundedTextAtTheEnd, GenerationNode parent) {
-    GenerationNode node = new GenerationNode(myTemplateToken, numberInIteration, totalIterations,
-                                             surroundedText, insertSurroundedTextAtTheEnd, parent);
-    return Arrays.asList(node);
+    TemplateToken templateToken = myTemplateToken;
+    String templateKey = templateToken.getKey();
+    if (myGenerator != null && StringUtil.containsChar(templateKey, '$') && callback.findApplicableTemplate(templateKey) == null) {
+      String newTemplateKey = ZenCodingUtil.replaceMarkers(templateKey, numberInIteration, totalIterations, surroundedText);
+      TemplateToken newTemplateToken = new TemplateToken(newTemplateKey,
+                                        templateToken.getAttribute2Value());
+
+      TemplateImpl template = myGenerator.createTemplateByKey(newTemplateKey);
+      if (template != null) {
+        newTemplateToken.setTemplate(template, callback);
+        templateToken = newTemplateToken;
+      }
   }
 
+  GenerationNode node = new GenerationNode(templateToken, numberInIteration, totalIterations,
+                                           surroundedText, insertSurroundedTextAtTheEnd, parent);
+  return Arrays.asList(node);
+}
+
   @Override
   public String toString() {
     String result = myTemplateToken.getKey();

From f8427d033686c318b66578a75e5684a9d3e6ec7d Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 16:30:32 +0400
Subject: [PATCH 177/354] EA-44218 - NPE: EncodingPanel.showPopup

---
 .../openapi/wm/impl/status/EncodingPanel.java         | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
index 5674fc400e3a..eddb5d23d1b9 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
@@ -181,10 +181,13 @@ public class EncodingPanel extends EditorBasedWidget implements StatusBarWidget.
     }
     DataContext dataContext = getContext();
     ListPopup popup = new ChangeFileEncodingAction().createPopup(dataContext);
-    Dimension dimension = popup.getContent().getPreferredSize();
-    Point at = new Point(0, -dimension.height);
-    popup.show(new RelativePoint(e.getComponent(), at));
-    Disposer.register(this, popup); // destroy popup on unexpected project close
+
+    if (popup != null) {
+      Dimension dimension = popup.getContent().getPreferredSize();
+      Point at = new Point(0, -dimension.height);
+      popup.show(new RelativePoint(e.getComponent(), at));
+      Disposer.register(this, popup); // destroy popup on unexpected project close
+    }
   }
 
   @NotNull

From 3f4bc3351f529907977eb97706fdb06545d8956d Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 17:45:28 +0400
Subject: [PATCH 178/354] notnull

---
 .../src/com/intellij/openapi/vfs/JarFileSystem.java    |  2 +-
 .../openapi/vfs/impl/jar/JarFileSystemImpl.java        | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/openapi/vfs/JarFileSystem.java b/platform/platform-api/src/com/intellij/openapi/vfs/JarFileSystem.java
index e1eadfccbe81..a5085ad741d3 100644
--- a/platform/platform-api/src/com/intellij/openapi/vfs/JarFileSystem.java
+++ b/platform/platform-api/src/com/intellij/openapi/vfs/JarFileSystem.java
@@ -34,7 +34,7 @@ public abstract class JarFileSystem extends NewVirtualFileSystem implements JarC
   @Nullable
   public abstract VirtualFile getVirtualFileForJar(@Nullable VirtualFile entryVFile);
   @Nullable
-  public abstract JarFile getJarFile(VirtualFile entryVFile) throws IOException;
+  public abstract JarFile getJarFile(@NotNull VirtualFile entryVFile) throws IOException;
 
   @SuppressWarnings("MethodMayBeStatic")
   @Nullable
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarFileSystemImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarFileSystemImpl.java
index a2a0c9ebd7ce..94475dc8035b 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarFileSystemImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarFileSystemImpl.java
@@ -110,7 +110,7 @@ public class JarFileSystemImpl extends JarFileSystem implements ApplicationCompo
   }
 
   @Nullable
-  private VirtualFile markDirty(final String path) {
+  private VirtualFile markDirty(@NotNull String path) {
     final JarHandler handler;
     synchronized (LOCK) {
       handler = myHandlers.remove(path);
@@ -162,20 +162,20 @@ public class JarFileSystemImpl extends JarFileSystem implements ApplicationCompo
   }
 
   @Override
-  public JarFile getJarFile(VirtualFile entryVFile) throws IOException {
+  public JarFile getJarFile(@NotNull VirtualFile entryVFile) throws IOException {
     JarHandler handler = getHandler(entryVFile);
 
     return handler.getJar();
   }
 
   @Nullable
-  public File getMirroredFile(VirtualFile vFile) {
+  public File getMirroredFile(@NotNull VirtualFile vFile) {
     VirtualFile jar = getJarRootForLocalFile(vFile);
     final JarHandler handler = jar != null ? getHandler(jar) : null;
     return handler != null ? handler.getMirrorFile(new File(vFile.getPath())) : null;
   }
 
-  private JarHandler getHandler(final VirtualFile entryVFile) {
+  private JarHandler getHandler(@NotNull VirtualFile entryVFile) {
     final String jarRootPath = extractRootPath(entryVFile.getPath());
 
     JarHandler handler;
@@ -260,7 +260,7 @@ public class JarFileSystemImpl extends JarFileSystem implements ApplicationCompo
     throw new IOException("Read-only: "+file.getPresentableUrl());
   }
 
-  public boolean isMakeCopyOfJar(File originalJar) {
+  public boolean isMakeCopyOfJar(@NotNull File originalJar) {
     if (myNoCopyJarPaths == null || myNoCopyJarPaths.contains(originalJar.getPath())) return false;
     if (myNoCopyJarDir != null && FileUtil.isAncestor(myNoCopyJarDir, originalJar, false)) return false;
     return true;

From d36a031d08ee4efb75342277954a72469665327d Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Mon, 25 Feb 2013 17:52:32 +0400
Subject: [PATCH 179/354] notnull

---
 .../openapi/vfs/impl/jar/CoreJarHandler.java  |  7 ++++---
 .../openapi/vfs/impl/jar/JarHandlerBase.java  | 20 +++++++++++--------
 .../openapi/vfs/impl/jar/JarHandler.java      |  9 ++++++---
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/CoreJarHandler.java b/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/CoreJarHandler.java
index 752e80e502a8..69c7d6df6332 100644
--- a/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/CoreJarHandler.java
+++ b/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/CoreJarHandler.java
@@ -30,7 +30,7 @@ public class CoreJarHandler extends JarHandlerBase {
   private final CoreJarFileSystem myFileSystem;
   private final VirtualFile myRoot;
 
-  public CoreJarHandler(CoreJarFileSystem fileSystem, String path) {
+  public CoreJarHandler(@NotNull CoreJarFileSystem fileSystem, @NotNull String path) {
     super(path);
     myFileSystem = fileSystem;
 
@@ -46,7 +46,7 @@ public class CoreJarHandler extends JarHandlerBase {
   }
 
   @NotNull
-  private CoreJarVirtualFile getOrCreateFile(EntryInfo info, Map<EntryInfo, CoreJarVirtualFile> entries) {
+  private CoreJarVirtualFile getOrCreateFile(@NotNull EntryInfo info, @NotNull Map<EntryInfo, CoreJarVirtualFile> entries) {
     CoreJarVirtualFile answer = entries.get(info);
     if (answer == null) {
       EntryInfo parentEntry = info.parent;
@@ -58,10 +58,11 @@ public class CoreJarHandler extends JarHandlerBase {
   }
 
   @Nullable
-  public VirtualFile findFileByPath(String pathInJar) {
+  public VirtualFile findFileByPath(@NotNull String pathInJar) {
     return myRoot != null ? myRoot.findFileByRelativePath(pathInJar) : null;
   }
 
+  @NotNull
   public CoreJarFileSystem getFileSystem() {
     return myFileSystem;
   }
diff --git a/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandlerBase.java b/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandlerBase.java
index c9b307399644..19af7b5efac2 100644
--- a/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandlerBase.java
+++ b/platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandlerBase.java
@@ -57,14 +57,14 @@ public class JarHandlerBase {
     protected final String shortName;
     protected final EntryInfo parent;
 
-    public EntryInfo(final String shortName, final EntryInfo parent, final boolean directory) {
+    public EntryInfo(@NotNull String shortName, final EntryInfo parent, final boolean directory) {
       this.shortName = shortName;
       this.parent = parent;
       isDirectory = directory;
     }
   }
 
-  public JarHandlerBase(String path) {
+  public JarHandlerBase(@NotNull String path) {
     myBasePath = path;
   }
 
@@ -100,7 +100,7 @@ public class JarHandlerBase {
     }
   }
 
-  public File getMirrorFile(File originalFile) {
+  public File getMirrorFile(@NotNull File originalFile) {
     return originalFile;
   }
 
@@ -203,11 +203,13 @@ public class JarHandlerBase {
     }
   }
 
+  @NotNull
   protected File getOriginalFile() {
     return new File(myBasePath);
   }
 
-  private static EntryInfo getOrCreate(String entryName, boolean isDirectory, Map<String, EntryInfo> map) {
+  @NotNull
+  private static EntryInfo getOrCreate(@NotNull String entryName, boolean isDirectory, @NotNull Map<String, EntryInfo> map) {
     EntryInfo info = map.get(entryName);
     if (info == null) {
       int idx = entryName.lastIndexOf('/');
@@ -238,28 +240,30 @@ public class JarHandlerBase {
     }
   }
 
-  protected EntryInfo getEntryInfo(final VirtualFile file) {
+  protected EntryInfo getEntryInfo(@NotNull VirtualFile file) {
     synchronized (lock) {
       String parentPath = getRelativePath(file);
       return getEntryInfo(parentPath);
     }
   }
 
-  public EntryInfo getEntryInfo(String parentPath) {
+  public EntryInfo getEntryInfo(@NotNull String parentPath) {
     return getEntriesMap().get(parentPath);
   }
 
+  @NotNull
   protected Map<String, EntryInfo> getEntriesMap() {
     return initEntries();
   }
 
-  private String getRelativePath(final VirtualFile file) {
+  @NotNull
+  private String getRelativePath(@NotNull VirtualFile file) {
     final String path = file.getPath().substring(myBasePath.length() + 1);
     return StringUtil.startsWithChar(path, '/') ? path.substring(1) : path;
   }
 
   @Nullable
-  private JarFile.JarEntry convertToEntry(VirtualFile file) {
+  private JarFile.JarEntry convertToEntry(@NotNull VirtualFile file) {
     String path = getRelativePath(file);
     final JarFile jar = getJar();
     return jar == null ? null : jar.getEntry(path);
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandler.java b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandler.java
index 49a2c03603d3..c992ca4b3fec 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandler.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandler.java
@@ -35,6 +35,7 @@ import com.intellij.openapi.vfs.VfsBundle;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.newvfs.NewVirtualFile;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
@@ -47,7 +48,7 @@ public class JarHandler extends JarHandlerBase {
 
   private final JarFileSystemImpl myFileSystem;
 
-  public JarHandler(final JarFileSystemImpl fileSystem, String path) {
+  public JarHandler(@NotNull JarFileSystemImpl fileSystem, @NotNull String path) {
     super(path);
     myFileSystem = fileSystem;
   }
@@ -71,7 +72,7 @@ public class JarHandler extends JarHandlerBase {
   }
 
   @Override
-  public File getMirrorFile(File originalFile) {
+  public File getMirrorFile(@NotNull File originalFile) {
     if (!myFileSystem.isMakeCopyOfJar(originalFile)) return originalFile;
 
     final FileAttributes originalAttributes = FileSystemUtil.getAttributes(originalFile);
@@ -95,12 +96,14 @@ public class JarHandler extends JarHandlerBase {
     return mirrorFile;
   }
 
+  @NotNull
   private static String getJarsDir() {
     String dir = System.getProperty("jars_dir");
     return dir == null ? PathManager.getSystemPath() + File.separatorChar + JARS_FOLDER : dir;
   }
 
-  private File copyToMirror(final File original, final File mirror) {
+  @NotNull
+  private File copyToMirror(@NotNull File original, @NotNull File mirror) {
     ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
     if (progress != null) {
       progress.pushState();

From 53e491ddc5dbeb34669596fdaf646a712c56e0f6 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Tue, 26 Feb 2013 14:27:12 +0400
Subject: [PATCH 180/354] removed diagnostics

---
 .../com/intellij/codeInspection/LossyEncodingInspection.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
index f9264265493e..e3eb52bde61d 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
@@ -29,6 +29,7 @@ import com.intellij.lang.properties.charset.Native2AsciiCharset;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
 import com.intellij.openapi.actionSystem.impl.SimpleDataContext;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
@@ -63,6 +64,8 @@ import java.util.Arrays;
 import java.util.List;
 
 public class LossyEncodingInspection extends LocalInspectionTool {
+  private static final Logger LOG = Logger.getInstance("#com.intellij.codeInspection.LossyEncodingInspection");
+
   private static final LocalQuickFix CHANGE_ENCODING_FIX = new ChangeEncodingFix();
   private static final LocalQuickFix RELOAD_ENCODING_FIX = new ReloadInAnotherEncodingFix();
 
@@ -159,7 +162,7 @@ public class LossyEncodingInspection extends LocalInspectionTool {
     }
 
     boolean equals = Arrays.equals(bytesToSave, bytes);
-    if (!equals) {
+    if (!equals && LOG.isDebugEnabled()) {
       try {
         FileUtil.writeToFile(new File("C:\\temp\\bytesToSave"), bytesToSave);
         FileUtil.writeToFile(new File("C:\\temp\\bytes"), bytes);

From 45c3feee70352595049fa47365ae185ae024af2f Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Tue, 26 Feb 2013 14:28:45 +0400
Subject: [PATCH 181/354] notnull

---
 .../EPAvailabilityListenerExtension.java      | 10 ++-
 .../openapi/extensions/Extension.java         |  6 +-
 .../openapi/extensions/ExtensionPoint.java    |  4 +
 .../openapi/extensions/ExtensionsArea.java    | 44 ++++++-----
 .../impl/ExtensionComponentAdapter.java       | 12 +--
 .../extensions/impl/ExtensionsAreaImpl.java   | 74 +++++++++----------
 .../impl/ExtensionPointImplTest.java          |  4 +-
 7 files changed, 80 insertions(+), 74 deletions(-)

diff --git a/platform/extensions/src/com/intellij/openapi/extensions/EPAvailabilityListenerExtension.java b/platform/extensions/src/com/intellij/openapi/extensions/EPAvailabilityListenerExtension.java
index 0f446a487d7d..21a75c9d802f 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/EPAvailabilityListenerExtension.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/EPAvailabilityListenerExtension.java
@@ -15,6 +15,8 @@
  */
 package com.intellij.openapi.extensions;
 
+import org.jetbrains.annotations.NotNull;
+
 /**
  * @author AKireyev
  */
@@ -28,24 +30,26 @@ public class EPAvailabilityListenerExtension implements PluginAware {
   public EPAvailabilityListenerExtension() {
   }
 
-  public EPAvailabilityListenerExtension(String extensionPointName, String listenerClass) {
+  public EPAvailabilityListenerExtension(@NotNull String extensionPointName, @NotNull String listenerClass) {
     myExtensionPointName = extensionPointName;
     myListenerClass = listenerClass;
   }
 
+  @NotNull
   public String getExtensionPointName() {
     return myExtensionPointName;
   }
 
-  public void setExtensionPointName(String extensionPointName) {
+  public void setExtensionPointName(@NotNull String extensionPointName) {
     myExtensionPointName = extensionPointName;
   }
 
+  @NotNull
   public String getListenerClass() {
     return myListenerClass;
   }
 
-  public void setListenerClass(String listenerClass) {
+  public void setListenerClass(@NotNull String listenerClass) {
     myListenerClass = listenerClass;
   }
 
diff --git a/platform/extensions/src/com/intellij/openapi/extensions/Extension.java b/platform/extensions/src/com/intellij/openapi/extensions/Extension.java
index fd416a6d224b..0f6a62c85e79 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/Extension.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/Extension.java
@@ -15,12 +15,14 @@
  */
 package com.intellij.openapi.extensions;
 
+import org.jetbrains.annotations.NotNull;
+
 /**
  * @author kir
  *
  * An extension can implement this interface to get notifications when it is added/removed to {@link ExtensionPoint}
  */
 public interface Extension {
-  void extensionAdded(ExtensionPoint extensionPoint);
-  void extensionRemoved(ExtensionPoint extensionPoint);
+  void extensionAdded(@NotNull ExtensionPoint extensionPoint);
+  void extensionRemoved(@NotNull ExtensionPoint extensionPoint);
 }
diff --git a/platform/extensions/src/com/intellij/openapi/extensions/ExtensionPoint.java b/platform/extensions/src/com/intellij/openapi/extensions/ExtensionPoint.java
index ec82f7535462..c019479b50d3 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/ExtensionPoint.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/ExtensionPoint.java
@@ -23,12 +23,14 @@ import org.jetbrains.annotations.Nullable;
  * @author AKireyev
  */
 public interface ExtensionPoint<T> {
+  @NotNull
   String getName();
   AreaInstance getArea();
 
   /**
    * @deprecated use {@link #getClassName()} instead
    */
+  @NotNull
   String getBeanClassName();
 
   void registerExtension(@NotNull T extension);
@@ -52,8 +54,10 @@ public interface ExtensionPoint<T> {
 
   Class<T> getExtensionClass();
 
+  @NotNull
   Kind getKind();
 
+  @NotNull
   String getClassName();
 
   enum Kind {INTERFACE, BEAN_CLASS}
diff --git a/platform/extensions/src/com/intellij/openapi/extensions/ExtensionsArea.java b/platform/extensions/src/com/intellij/openapi/extensions/ExtensionsArea.java
index 3f31a2e8aecf..6dcac22e4401 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/ExtensionsArea.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/ExtensionsArea.java
@@ -18,6 +18,7 @@ package com.intellij.openapi.extensions;
 import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.picocontainer.PicoContainer;
 
 import java.util.List;
@@ -26,41 +27,44 @@ import java.util.List;
  * @author AKireyev
  */
 public interface ExtensionsArea  {
-  void registerExtensionPoint(@NonNls String extensionPointName, String extensionPointBeanClass);
-  void registerExtensionPoint(@NonNls String extensionPointName, String extensionPointBeanClass, ExtensionPoint.Kind kind);
-  void unregisterExtensionPoint(@NonNls String extensionPointName);
+  void registerExtensionPoint(@NonNls @NotNull String extensionPointName, @NotNull String extensionPointBeanClass);
+  void registerExtensionPoint(@NonNls @NotNull String extensionPointName, @NotNull String extensionPointBeanClass, @NotNull ExtensionPoint.Kind kind);
+  void registerExtensionPoint(@NotNull String extensionPointName, @NotNull String extensionPointBeanClass, @NotNull PluginDescriptor descriptor);
+  void unregisterExtensionPoint(@NonNls @NotNull String extensionPointName);
 
-  boolean hasExtensionPoint(@NonNls String extensionPointName);
+  boolean hasExtensionPoint(@NonNls @NotNull String extensionPointName);
   @NotNull
-  <T> ExtensionPoint<T> getExtensionPoint(@NonNls String extensionPointName);
-  <T> ExtensionPoint<T> getExtensionPoint(ExtensionPointName<T> extensionPointName);
+  <T> ExtensionPoint<T> getExtensionPoint(@NonNls @NotNull String extensionPointName);
 
+  <T> ExtensionPoint<T> getExtensionPoint(@NotNull ExtensionPointName<T> extensionPointName);
+
+  @NotNull
   ExtensionPoint[] getExtensionPoints();
-
   void suspendInteractions();
   void resumeInteractions();
+
   void killPendingInteractions();
 
-  void addAvailabilityListener(String epName, ExtensionPointAvailabilityListener listener);
+  void addAvailabilityListener(@NotNull String extensionPointName, @NotNull ExtensionPointAvailabilityListener listener);
 
+  @NotNull
   AreaPicoContainer getPicoContainer();
+  void registerExtensionPoint(@NotNull String pluginName, @NotNull Element extensionPointElement);
+  void registerExtensionPoint(@NotNull PluginDescriptor pluginDescriptor, @NotNull Element extensionPointElement);
+  void registerExtension(@NotNull String pluginName, @NotNull Element extensionElement);
 
-  void registerExtensionPoint(String pluginName, Element extensionPointElement);
-  void registerExtensionPoint(PluginDescriptor pluginDescriptor, Element extensionPointElement);
-  void registerExtension(String pluginName, Element extensionElement);
-  void registerExtension(PluginDescriptor pluginDescriptor, Element extensionElement);
+  void registerExtension(@NotNull PluginDescriptor pluginDescriptor, @NotNull Element extensionElement);
 
-  void unregisterExtensionPoint(String pluginName, Element extensionPointElement);
+  void unregisterExtensionPoint(@NotNull String pluginName, @NotNull Element extensionPointElement);
 
-  void unregisterExtension(String pluginName, Element extensionElement);
+  void unregisterExtension(@NotNull String pluginName, @NotNull Element extensionElement);
 
-  PicoContainer getPluginContainer(String pluginName);
+  @NotNull
+  PicoContainer getPluginContainer(@NotNull String pluginName);
 
   String getAreaClass();
 
-  void registerExtensionPoint(String extensionPointName, String extensionPointBeanClass, PluginDescriptor descriptor);
-
-  void registerAreaExtensionsAndPoints(final PluginDescriptor pluginDescriptor,
-                                       final List<Element> extensionsPoints,
-                                       final List<Element> extensions);
+  void registerAreaExtensionsAndPoints(@NotNull PluginDescriptor pluginDescriptor,
+                                       @Nullable List<Element> extensionsPoints,
+                                       @Nullable List<Element> extensions);
 }
diff --git a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionComponentAdapter.java b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionComponentAdapter.java
index e4a6bd3616fa..d081d55d1810 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionComponentAdapter.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionComponentAdapter.java
@@ -19,6 +19,7 @@ import com.intellij.openapi.extensions.*;
 import com.intellij.util.pico.AssignableToComponentAdapter;
 import com.intellij.util.xmlb.XmlSerializer;
 import org.jdom.Element;
+import org.jetbrains.annotations.NotNull;
 import org.picocontainer.*;
 import org.picocontainer.defaults.AssignabilityRegistrationException;
 import org.picocontainer.defaults.CachingComponentAdapter;
@@ -40,12 +41,11 @@ public class ExtensionComponentAdapter implements LoadingOrder.Orderable, Assign
   private ComponentAdapter myDelegate;
   private Class myImplementationClass;
 
-  public ExtensionComponentAdapter(
-    String implementationClass,
-    Element extensionElement,
-    PicoContainer container,
-    PluginDescriptor pluginDescriptor,
-    boolean deserializeInstance) {
+  public ExtensionComponentAdapter(@NotNull String implementationClass,
+                                   Element extensionElement,
+                                   PicoContainer container,
+                                   PluginDescriptor pluginDescriptor,
+                                   boolean deserializeInstance) {
     myImplementationClassName = implementationClass;
     myExtensionElement = extensionElement;
     myContainer = container;
diff --git a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionsAreaImpl.java b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionsAreaImpl.java
index 1354c41f38ac..ee8f85f1a901 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionsAreaImpl.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionsAreaImpl.java
@@ -25,11 +25,11 @@ import org.jdom.output.Format;
 import org.jdom.output.XMLOutputter;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.picocontainer.MutablePicoContainer;
 import org.picocontainer.PicoContainer;
 import org.picocontainer.defaults.ConstructorInjectionComponentAdapter;
-import org.picocontainer.defaults.DefaultPicoContainer;
 
 import java.io.IOException;
 import java.io.StringWriter;
@@ -59,7 +59,6 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   private final AreaInstance myAreaInstance;
   private final String myAreaClass;
   private final Map<Element,ExtensionComponentAdapter> myExtensionElement2extension = new HashMap<Element, ExtensionComponentAdapter>();
-  private final Map<String,DefaultPicoContainer> myPluginName2picoContainer = new HashMap<String, DefaultPicoContainer>();
 
   public ExtensionsAreaImpl(String areaClass, AreaInstance areaInstance, PicoContainer parentPicoContainer, @NotNull LogProvider logger) {
     myCreationTrace = DEBUG_REGISTRATION ? new Throwable("Area creation trace") : null;
@@ -81,6 +80,7 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     }
   }
 
+  @NotNull
   @Override
   public AreaPicoContainer getPicoContainer() {
     return myPicoContainer;
@@ -96,12 +96,12 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   }
 
   @Override
-  public void registerExtensionPoint(String pluginName, Element extensionPointElement) {
+  public void registerExtensionPoint(@NotNull String pluginName, @NotNull Element extensionPointElement) {
     registerExtensionPoint(new DefaultPluginDescriptor(PluginId.getId(pluginName)), extensionPointElement);
   }
 
   @Override
-  public void registerExtensionPoint(PluginDescriptor pluginDescriptor, Element extensionPointElement) {
+  public void registerExtensionPoint(@NotNull PluginDescriptor pluginDescriptor, @NotNull Element extensionPointElement) {
     assert pluginDescriptor.getPluginId() != null;
     final String pluginId = pluginDescriptor.getPluginId().getIdString();
     String epName = extensionPointElement.getAttributeValue("qualifiedName");
@@ -136,12 +136,12 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   }
 
   @Override
-  public void registerExtension(final String pluginName, final Element extensionElement) {
+  public void registerExtension(@NotNull final String pluginName, @NotNull final Element extensionElement) {
     registerExtension(new DefaultPluginDescriptor(PluginId.getId(pluginName)), extensionElement);
   }
 
   @Override
-  public void registerExtension(final PluginDescriptor pluginDescriptor, final Element extensionElement) {
+  public void registerExtension(@NotNull final PluginDescriptor pluginDescriptor, @NotNull final Element extensionElement) {
     final PluginId pluginId = pluginDescriptor.getPluginId();
 
     String epName = extractEPName(extensionElement);
@@ -194,8 +194,9 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     return epName;
   }
 
+  @NotNull
   @Override
-  public PicoContainer getPluginContainer(String pluginName) {
+  public PicoContainer getPluginContainer(@NotNull String pluginName) {
     return internalGetPluginContainer();
   }
 
@@ -203,22 +204,14 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     return myPicoContainer;
   }
 
-  private void disposePluginContainer(String pluginName) {
-    DefaultPicoContainer pluginContainer = myPluginName2picoContainer.remove(pluginName);
-    if (pluginContainer != null) {
-      myPicoContainer.removeChildContainer(pluginContainer);
-    }
-  }
-
   @Override
-  public void unregisterExtensionPoint(String pluginName, Element extensionPointElement) {
-    assert pluginName != null;
+  public void unregisterExtensionPoint(@NotNull String pluginName, @NotNull Element extensionPointElement) {
     String epName = pluginName + '.' + extensionPointElement.getAttributeValue("name");
     unregisterExtensionPoint(epName);
   }
 
   @Override
-  public void unregisterExtension(String pluginName, Element extensionElement) {
+  public void unregisterExtension(@NotNull String pluginName, @NotNull Element extensionElement) {
     String epName = extractEPName(extensionElement);
     if (!myExtensionElement2extension.containsKey(extensionElement)) {
       XMLOutputter xmlOutputter = new XMLOutputter();
@@ -239,9 +232,6 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     if (getExtensionPoint(epName).unregisterComponentAdapter(adapter)) {
       MutablePicoContainer pluginContainer = internalGetPluginContainer();
       pluginContainer.unregisterComponent(adapter.getComponentKey());
-      if (pluginContainer.getComponentAdapters().isEmpty()) {
-        disposePluginContainer(pluginName);
-      }
     }
   }
 
@@ -297,32 +287,32 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   }
 
   @Override
-  public void addAvailabilityListener(String epName, ExtensionPointAvailabilityListener listener) {
-    myAvailabilityListeners.putValue(epName, listener);
-    if (hasExtensionPoint(epName)) {
-      notifyAvailableListener(listener, myExtensionPoints.get(epName));
+  public void addAvailabilityListener(@NotNull String extensionPointName, @NotNull ExtensionPointAvailabilityListener listener) {
+    myAvailabilityListeners.putValue(extensionPointName, listener);
+    if (hasExtensionPoint(extensionPointName)) {
+      notifyAvailableListener(listener, myExtensionPoints.get(extensionPointName));
     }
   }
 
   @Override
-  public void registerExtensionPoint(final String extensionPointName, String extensionPointBeanClass) {
+  public void registerExtensionPoint(@NotNull final String extensionPointName, @NotNull String extensionPointBeanClass) {
     registerExtensionPoint(extensionPointName, extensionPointBeanClass, ExtensionPoint.Kind.INTERFACE);
   }
 
   @Override
-  public void registerExtensionPoint(@NonNls String extensionPointName, String extensionPointBeanClass, ExtensionPoint.Kind kind) {
+  public void registerExtensionPoint(@NotNull @NonNls String extensionPointName, @NotNull String extensionPointBeanClass, @NotNull ExtensionPoint.Kind kind) {
     registerExtensionPoint(extensionPointName, extensionPointBeanClass, new UndefinedPluginDescriptor(), kind);
   }
 
   @Override
-  public void registerExtensionPoint(final String extensionPointName, String extensionPointBeanClass, PluginDescriptor descriptor) {
+  public void registerExtensionPoint(@NotNull final String extensionPointName, @NotNull String extensionPointBeanClass, @NotNull PluginDescriptor descriptor) {
     registerExtensionPoint(extensionPointName, extensionPointBeanClass, descriptor, ExtensionPoint.Kind.INTERFACE);
   }
 
-  private void registerExtensionPoint(final String extensionPointName,
-                                     String extensionPointBeanClass,
-                                     PluginDescriptor descriptor,
-                                     ExtensionPoint.Kind kind) {
+  private void registerExtensionPoint(@NotNull String extensionPointName,
+                                      @NotNull String extensionPointBeanClass,
+                                      @NotNull PluginDescriptor descriptor,
+                                      @NotNull ExtensionPoint.Kind kind) {
     if (hasExtensionPoint(extensionPointName)) {
       if (DEBUG_REGISTRATION) {
         final ExtensionPointImpl oldEP = getExtensionPoint(extensionPointName);
@@ -336,8 +326,8 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     registerExtensionPoint(new ExtensionPointImpl(extensionPointName, extensionPointBeanClass, kind, this, myAreaInstance, myLogger, descriptor));
   }
 
-  public void registerExtensionPoint(final ExtensionPointImpl extensionPoint) {
-    final String name = extensionPoint.getName();
+  public void registerExtensionPoint(@NotNull ExtensionPointImpl extensionPoint) {
+    String name = extensionPoint.getName();
     myExtensionPoints.put(name, extensionPoint);
     notifyEPRegistered(extensionPoint);
     if (DEBUG_REGISTRATION) {
@@ -346,9 +336,9 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   }
 
   @Override
-  public void registerAreaExtensionsAndPoints(final PluginDescriptor pluginDescriptor,
-                                              final List<Element> extensionsPoints,
-                                              final List<Element> extensions) {
+  public void registerAreaExtensionsAndPoints(@NotNull final PluginDescriptor pluginDescriptor,
+                                              @Nullable List<Element> extensionsPoints,
+                                              @Nullable List<Element> extensions) {
     final String areaClass = getAreaClass();
     if (extensionsPoints != null) {
       //noinspection ForLoopReplaceableByForEach
@@ -406,7 +396,7 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
 
   @Override
   @NotNull
-  public <T> ExtensionPointImpl<T> getExtensionPoint(String extensionPointName) {
+  public <T> ExtensionPointImpl<T> getExtensionPoint(@NotNull String extensionPointName) {
     ExtensionPointImpl<T> extensionPoint = myExtensionPoints.get(extensionPointName);
     if (extensionPoint == null) {
       throw new IllegalArgumentException("Missing extension point: " + extensionPointName + " in area " + myAreaInstance);
@@ -416,17 +406,18 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
 
   @Override
   @SuppressWarnings({"unchecked"})
-  public <T> ExtensionPoint<T> getExtensionPoint(ExtensionPointName<T> extensionPointName) {
+  public <T> ExtensionPoint<T> getExtensionPoint(@NotNull ExtensionPointName<T> extensionPointName) {
     return getExtensionPoint(extensionPointName.getName());
   }
 
+  @NotNull
   @Override
   public ExtensionPoint[] getExtensionPoints() {
     return myExtensionPoints.values().toArray(new ExtensionPoint[myExtensionPoints.size()]);
   }
 
   @Override
-  public void unregisterExtensionPoint(final String extensionPointName) {
+  public void unregisterExtensionPoint(@NotNull final String extensionPointName) {
     ExtensionPoint extensionPoint = myExtensionPoints.get(extensionPointName);
     if (extensionPoint != null) {
       extensionPoint.reset();
@@ -453,7 +444,7 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
   }
 
   @Override
-  public boolean hasExtensionPoint(String extensionPointName) {
+  public boolean hasExtensionPoint(@NotNull String extensionPointName) {
     return myExtensionPoints.containsKey(extensionPointName);
   }
 
@@ -485,8 +476,9 @@ public class ExtensionsAreaImpl implements ExtensionsArea {
     mySuspendedListenerActions.clear();
   }
 
+  @NotNull
   public MutablePicoContainer[] getPluginContainers() {
-    return myPluginName2picoContainer.values().toArray(new MutablePicoContainer[myPluginName2picoContainer.values().size()]);
+    return new MutablePicoContainer[0];
   }
 
   public void removeAllComponents(final Set<ExtensionComponentAdapter> extensionAdapters) {
diff --git a/platform/extensions/testSrc/com/intellij/openapi/extensions/impl/ExtensionPointImplTest.java b/platform/extensions/testSrc/com/intellij/openapi/extensions/impl/ExtensionPointImplTest.java
index a225479abc90..d39b9a31340d 100644
--- a/platform/extensions/testSrc/com/intellij/openapi/extensions/impl/ExtensionPointImplTest.java
+++ b/platform/extensions/testSrc/com/intellij/openapi/extensions/impl/ExtensionPointImplTest.java
@@ -56,14 +56,14 @@ public class ExtensionPointImplTest extends TestCase {
     final boolean[] flags = new boolean[2];
     Extension extension = new Extension() {
       @Override
-      public void extensionAdded(ExtensionPoint extensionPoint1) {
+      public void extensionAdded(@NotNull ExtensionPoint extensionPoint1) {
         assertSame(extensionPoint, extensionPoint1);
         assertSame(area, extensionPoint1.getArea());
         flags[0] = true;
       }
 
       @Override
-      public void extensionRemoved(ExtensionPoint extensionPoint1) {
+      public void extensionRemoved(@NotNull ExtensionPoint extensionPoint1) {
         assertSame(extensionPoint, extensionPoint1);
         assertSame(area, extensionPoint1.getArea());
         flags[1] = true;

From 18327f67cec4ca255d720b8036e1a2d9f3541ca1 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Tue, 26 Feb 2013 14:30:28 +0400
Subject: [PATCH 182/354] intern component name to avoid duplicate string for
 each of 400+ modules

---
 .../extensions/impl/ExtensionPointImpl.java   | 39 ++++++++++++-------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionPointImpl.java b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionPointImpl.java
index d9bd4e1f53c6..44058e8516b1 100644
--- a/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionPointImpl.java
+++ b/platform/extensions/src/com/intellij/openapi/extensions/impl/ExtensionPointImpl.java
@@ -20,7 +20,9 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.*;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.util.ArrayUtil;
+import com.intellij.util.ArrayUtilRt;
 import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.StringInterner;
 import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -56,14 +58,18 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
 
   private Class<T> myExtensionClass;
 
-  public ExtensionPointImpl(String name,
-                            String className,
-                            Kind kind,
-                            ExtensionsAreaImpl owner,
+  private static final StringInterner INTERNER = new StringInterner();
+
+  public ExtensionPointImpl(@NotNull String name,
+                            @NotNull String className,
+                            @NotNull Kind kind,
+                            @NotNull ExtensionsAreaImpl owner,
                             AreaInstance area,
-                            LogProvider logger,
-                            PluginDescriptor descriptor) {
-    myName = name;
+                            @NotNull LogProvider logger,
+                            @NotNull PluginDescriptor descriptor) {
+    synchronized (INTERNER) {
+      myName = INTERNER.intern(name);
+    }
     myClassName = className;
     myKind = kind;
     myOwner = owner;
@@ -72,6 +78,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     myDescriptor = descriptor;
   }
 
+  @NotNull
   @Override
   public String getName() {
     return myName;
@@ -82,16 +89,19 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     return myArea;
   }
 
+  @NotNull
   @Override
   public String getBeanClassName() {
     return myClassName;
   }
 
+  @NotNull
   @Override
   public String getClassName() {
     return myClassName;
   }
 
+  @NotNull
   @Override
   public Kind getKind() {
     return myKind;
@@ -102,6 +112,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     registerExtension(extension, LoadingOrder.ANY);
   }
 
+  @NotNull
   public PluginDescriptor getDescriptor() {
     return myDescriptor;
   }
@@ -130,7 +141,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     clearCache();
   }
 
-  private void internalRegisterExtension(T extension, ExtensionComponentAdapter adapter, int index, boolean runNotifications) {
+  private void internalRegisterExtension(@NotNull T extension, @NotNull ExtensionComponentAdapter adapter, int index, boolean runNotifications) {
     if (myExtensions.contains(extension)) {
       myLogger.error("Extension was already added: " + extension);
       return;
@@ -152,7 +163,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     }
   }
 
-  private void notifyListenersOnAdd(T extension, final PluginDescriptor pluginDescriptor) {
+  private void notifyListenersOnAdd(@NotNull T extension, final PluginDescriptor pluginDescriptor) {
     for (ExtensionPointListener<T> listener : myEPListeners) {
       try {
         listener.extensionAdded(extension, pluginDescriptor);
@@ -180,7 +191,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
             T t = result[i];
             if (i > 0 && result[i] == result[i - 1]) {
               LOG.error("Duplicate extension found: " + t + "; " +
-                        " Result:      " + Arrays.asList(result) + ";\n" +
+                        " Result:      " + Arrays.toString(result) + ";\n" +
                         " extensions: " + myExtensions + ";\n" +
                         " getExtensionClass(): " + extensionClass + ";\n" +
                         " size:" + myExtensions.size() + ";" + result.length);
@@ -230,7 +241,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
         T extension = (T)adapter.getExtension();
         assertClass(extension.getClass());
 
-        internalRegisterExtension(extension, adapter, myExtensions.size(), ArrayUtil.find(loadedAdapters, adapter) == -1);
+        internalRegisterExtension(extension, adapter, myExtensions.size(), ArrayUtilRt.find(loadedAdapters, adapter) == -1);
       }
       myExtensionAdapters.clear();
     }
@@ -273,7 +284,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     return i;
   }
 
-  private void internalUnregisterExtension(T extension, PluginDescriptor pluginDescriptor) {
+  private void internalUnregisterExtension(@NotNull T extension, PluginDescriptor pluginDescriptor) {
     int index = getExtensionIndex(extension);
     myExtensions.remove(index);
 
@@ -294,7 +305,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     }
   }
 
-  private void notifyListenersOnRemove(T extensionObject, PluginDescriptor pluginDescriptor) {
+  private void notifyListenersOnRemove(@NotNull T extensionObject, PluginDescriptor pluginDescriptor) {
     for (ExtensionPointListener<T> listener : myEPListeners) {
       try {
         listener.extensionRemoved(extensionObject, pluginDescriptor);
@@ -397,7 +408,7 @@ public class ExtensionPointImpl<T> implements ExtensionPoint<T> {
     myExtensionsCache = null;
   }
 
-  synchronized boolean unregisterComponentAdapter(final ExtensionComponentAdapter componentAdapter) {
+  synchronized boolean unregisterComponentAdapter(@NotNull ExtensionComponentAdapter componentAdapter) {
     try {
       if (myExtensionAdapters.remove(componentAdapter)) {
         return true;

From 98810c7341a7a0c927491ff5e499726458c7643b Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Tue, 26 Feb 2013 14:31:17 +0400
Subject: [PATCH 183/354] javadoc, renames

---
 .../vfs/newvfs/impl/VirtualDirectoryImpl.java | 140 ++++++++++--------
 .../vfs/newvfs/persistent/FSRecords.java      |   5 +
 2 files changed, 85 insertions(+), 60 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
index cfbbe4319639..37b81a28ca7f 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java
@@ -62,10 +62,17 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
 
   private final NewVirtualFileSystem myFS;
 
-  // stores child files. The array is logically divided into the two parts:
-  // left subarray for storing real files, right subarray for storing fake files with "suspicious" names
-  // files in each subarray are sorted according to the compareNameTo() comparator
-  // guarded by this, either real file or fake file (meaning it's not a real child but suspicious name)
+  /**
+   *   The array is logically divided into the two parts:
+   *  - left subarray for storing real child files
+   *  - right subarray for storing "adopted children" files.
+   *  "Adopted children" are fake files which are used for storing names which were accessed via findFileByName() or similar calls.
+   *  We have to store these unsuccessful find attempts to be able to correctly refresh in the future.
+   *  See usages of {@link #getSuspiciousNames()} in the {@link com.intellij.openapi.vfs.newvfs.persistent.RefreshWorker}
+   *
+   *  Guarded by this, files in each subarray are sorted according to the compareNameTo() comparator
+   *  TODO: revise the whole adopted scheme
+   */
   private VirtualFileSystemEntry[] myChildren = EMPTY_ARRAY;
 
   public VirtualDirectoryImpl(@NonNls @NotNull final String name,
@@ -100,17 +107,17 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     }
 
     if (result == null) {
-      addToSuspiciousNames(name, !delegate.isCaseSensitive());
+      addToAdoptedChildren(name, !delegate.isCaseSensitive());
     }
     return result;
   }
 
-  private synchronized void addToSuspiciousNames(@NotNull final String name, final boolean ignoreCase) {
+  private synchronized void addToAdoptedChildren(@NotNull final String name, final boolean ignoreCase) {
     if (allChildrenLoaded()) return;
     int index = binSearch(myChildren, 0, myChildren.length, new Comparer() {
       @Override
       public int compareMyKeyTo(@NotNull VirtualFileSystemEntry file) {
-        if (!isSuspiciousName(file)) return 1;
+        if (!isAdoptedChild(file)) return 1;
         return -file.compareNameTo(name, ignoreCase);
       }
     });
@@ -123,8 +130,8 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     VirtualFileSystemEntry[] array = myChildren;
     long r = findIndexInBoth(array, comparer);
     int indexInReal = (int)(r >> 32);
-    int indexInSuspicious = (int)r;
-    if (indexInSuspicious >= 0) return NULL_VIRTUAL_FILE;
+    int indexInAdopted = (int)r;
+    if (indexInAdopted >= 0) return NULL_VIRTUAL_FILE;
 
     if (indexInReal >= 0) {
       return array[indexInReal];
@@ -163,8 +170,8 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
       VirtualFileSystemEntry[] array = myChildren;
       long r = findIndexInBoth(array, comparer);
       int indexInReal = (int)(r >> 32);
-      int indexInSuspicious = (int)r;
-      if (indexInSuspicious >= 0) return NULL_VIRTUAL_FILE;
+      int indexInAdopted = (int)r;
+      if (indexInAdopted >= 0) return NULL_VIRTUAL_FILE;
       // double check
       if (indexInReal >= 0) {
         return array[indexInReal];
@@ -356,33 +363,33 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
   private static int findIndexInOneHalf(final VirtualFileSystemEntry[] array,
                                         int start,
                                         int end,
-                                        final boolean isSuspicious,
+                                        final boolean isAdopted,
                                         @NotNull final Comparer comparer) {
     return binSearch(array, start, end, new Comparer() {
       @Override
       public int compareMyKeyTo(@NotNull VirtualFileSystemEntry file) {
-        if (isSuspicious && !isSuspiciousName(file)) return 1;
-        if (!isSuspicious && isSuspiciousName(file)) return -1;
+        if (isAdopted && !isAdoptedChild(file)) return 1;
+        if (!isAdopted && isAdoptedChild(file)) return -1;
         return comparer.compareMyKeyTo(file);
       }
     });
   }
 
-  // returns two int indices packed into one long. left index is for the real file array half, right is for the suspicious name array
+  // returns two int indices packed into one long. left index is for the real file array half, right is for the adopted children name array
   private static long findIndexInBoth(@NotNull VirtualFileSystemEntry[] array, @NotNull Comparer comparer) {
     int high = array.length - 1;
     if (high == -1) {
       return pack(-1, -1);
     }
     int low = 0;
-    boolean startInSuspicious = isSuspiciousName(array[low]);
-    boolean endInSuspicious = isSuspiciousName(array[high]);
-    if (startInSuspicious == endInSuspicious) {
-      int index = findIndexInOneHalf(array, low, high + 1, startInSuspicious, comparer);
-      int otherIndex = startInSuspicious ? -1 : -array.length - 1;
-      return startInSuspicious ? pack(otherIndex, index) : pack(index, otherIndex);
+    boolean startInAdopted = isAdoptedChild(array[low]);
+    boolean endInAdopted = isAdoptedChild(array[high]);
+    if (startInAdopted == endInAdopted) {
+      int index = findIndexInOneHalf(array, low, high + 1, startInAdopted, comparer);
+      int otherIndex = startInAdopted ? -1 : -array.length - 1;
+      return startInAdopted ? pack(otherIndex, index) : pack(index, otherIndex);
     }
-    boolean suspicious = false;
+    boolean adopted = false;
     int cmp = -1;
     int mid = -1;
     int foundIndex = -1;
@@ -390,15 +397,15 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
       mid = low + high >>> 1;
       VirtualFileSystemEntry file = array[mid];
       cmp = comparer.compareMyKeyTo(file);
-      suspicious = isSuspiciousName(file);
+      adopted = isAdoptedChild(file);
       if (cmp == 0) {
         foundIndex = mid;
         break;
       }
-      if ((suspicious || cmp <= 0) && (!suspicious || cmp >= 0)) {
-        int indexInSuspicious = findIndexInOneHalf(array, mid + 1, high + 1, true, comparer);
+      if ((adopted || cmp <= 0) && (!adopted || cmp >= 0)) {
+        int indexInAdopted = findIndexInOneHalf(array, mid + 1, high + 1, true, comparer);
         int indexInReal = findIndexInOneHalf(array, low, mid, false, comparer);
-        return pack(indexInReal, indexInSuspicious);
+        return pack(indexInReal, indexInAdopted);
       }
 
       if (cmp > 0) {
@@ -411,14 +418,14 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
 
     // key not found.
     if (cmp != 0) foundIndex = -low-1;
-    int newStart = suspicious ? low : mid + 1;
-    int newEnd = suspicious ? mid + 1 : high + 1;
-    int theOtherHalfIndex = newStart < newEnd ? findIndexInOneHalf(array, newStart, newEnd, !suspicious, comparer) : -newStart-1;
-    return suspicious ? pack(theOtherHalfIndex, foundIndex) : pack(foundIndex, theOtherHalfIndex);
+    int newStart = adopted ? low : mid + 1;
+    int newEnd = adopted ? mid + 1 : high + 1;
+    int theOtherHalfIndex = newStart < newEnd ? findIndexInOneHalf(array, newStart, newEnd, !adopted, comparer) : -newStart-1;
+    return adopted ? pack(theOtherHalfIndex, foundIndex) : pack(foundIndex, theOtherHalfIndex);
   }
 
-  private static long pack(int indexInReal, int indexInSuspicious) {
-    return (long)indexInReal << 32 | (indexInSuspicious & 0xffffffffL);
+  private static long pack(int indexInReal, int indexInAdopted) {
+    return (long)indexInReal << 32 | (indexInAdopted & 0xffffffffL);
   }
 
   @Override
@@ -455,8 +462,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     final boolean ignoreCase = !delegate.isCaseSensitive();
     if (allChildrenLoaded()) {
       assertConsistency(children, ignoreCase);
-      int sas = getSuspiciousArrayStart();
-      return sas == children.length ? children : Arrays.copyOf(children, sas);
+      return children;
     }
 
     FSRecords.NameId[] childrenIds = ourPersistence.listAll(this);
@@ -475,16 +481,19 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
       });
       result = new VirtualFileSystemEntry[childrenIds.length];
       int delegateI = 0;
-      int cachedI = 0;
+      int i = 0;
 
-      int cachedEnd = getSuspiciousArrayStart();
+      int cachedEnd = getAdoptedChildrenStart();
+      // merge (sorted) children[0..cachedEnd) and childrenIds into the result array.
+      // file that is already in children array must be copied into the result as is
+      // for the file name that is new in childrenIds the file must be created and copied into result
       while (delegateI < childrenIds.length) {
         FSRecords.NameId nameId = childrenIds[delegateI];
-        while (cachedI < cachedEnd && children[cachedI].compareNameTo(nameId.name, ignoreCase) < 0) cachedI++;
+        while (i < cachedEnd && children[i].compareNameTo(nameId.name, ignoreCase) < 0) i++; // skip files that are not in childrenIds
 
         VirtualFileSystemEntry resultFile;
-        if (cachedI < cachedEnd && children[cachedI].compareNameTo(nameId.name, ignoreCase) == 0) {
-          resultFile = children[cachedI++];
+        if (i < cachedEnd && children[i].compareNameTo(nameId.name, ignoreCase) == 0) {
+          resultFile = children[i++];
         }
         else {
           resultFile = createChild(nameId.name, nameId.id, delegate);
@@ -492,7 +501,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
         result[delegateI++] = resultFile;
       }
 
-      assertConsistency(result, ignoreCase);
+      assertConsistency(result, ignoreCase, children, cachedEnd, childrenIds);
     }
 
     if (getId() > 0) {
@@ -503,20 +512,31 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     return result;
   }
 
-  private static void assertConsistency(@NotNull VirtualFileSystemEntry[] array, boolean ignoreCase) {
+  private void assertConsistency(@NotNull VirtualFileSystemEntry[] array, boolean ignoreCase, @NotNull Object... details) {
     if (!CHECK) return;
+    boolean allChildrenLoaded = allChildrenLoaded();
     for (int i = 0; i < array.length; i++) {
       VirtualFileSystemEntry file = array[i];
-      if (isSuspiciousName(file) && i != array.length - 1 ) {
-        assert isSuspiciousName(array[i + 1]);
+      boolean isAdopted = isAdoptedChild(file);
+      assert !isAdopted || !allChildrenLoaded;
+      if (isAdopted && i != array.length - 1) {
+        assert isAdoptedChild(array[i + 1]);
       }
       if (i != 0) {
         String prevName = array[i - 1].getName();
         int cmp = file.compareNameTo(prevName, ignoreCase);
-        assert cmp != 0 : prevName + " equals to "+ file+"; children: "+Arrays.toString(array);
+        if (cmp == 0) {
+          throw new AssertionError(
+            prevName + " equals to " + file + "; children: " + Arrays.toString(array) + "\nDetails: " + ContainerUtil.map(details, new Function<Object, Object>() {
+              @Override
+              public Object fun(Object o) {
+                return o instanceof Object[] ? Arrays.toString((Object[])o) : o;
+              }
+            }));
+        }
 
-        if (isSuspiciousName(file) == isSuspiciousName(array[i - 1])) {
-          assert cmp > 0 : "Not sorted";
+        if (isAdopted == isAdoptedChild(array[i - 1])) {
+          assert cmp > 0 : "Not sorted. "+Arrays.toString(details);
         }
       }
     }
@@ -557,17 +577,17 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     final boolean ignoreCase = !getFileSystem().isCaseSensitive();
     long r = findIndexInBoth(array, getComparer(childName, ignoreCase));
     int indexInReal = (int)(r >> 32);
-    int indexInSuspicious = (int)r;
+    int indexInAdopted = (int)r;
 
-    if (indexInSuspicious >= 0) {
-      // remove suspicious first
-      myChildren = array = ArrayUtil.remove(array, indexInSuspicious, new ArrayFactory<VirtualFileSystemEntry>() {
+    if (indexInAdopted >= 0) {
+      // remove Adopted first
+      myChildren = array = ArrayUtil.remove(array, indexInAdopted, new ArrayFactory<VirtualFileSystemEntry>() {
         @Override
         public VirtualFileSystemEntry[] create(int count) {
           return new VirtualFileSystemEntry[count];
         }
       });
-      assertConsistency(myChildren, ignoreCase);
+      assertConsistency(array, ignoreCase, child);
     }
     if (indexInReal >= 0) return; // already stored
 
@@ -580,7 +600,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     System.arraycopy(array, 0, appended, 0, i);
     appended[i] = file;
     System.arraycopy(array, i, appended, i+1, array.length - i);
-    assertConsistency(appended, ignoreCase);
+    assertConsistency(appended, ignoreCase, file, i);
     myChildren = appended;
   }
 
@@ -594,8 +614,8 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
         return new VirtualFileSystemEntry[count];
       }
     });
-    addToSuspiciousNames(name, ignoreCase);
-    assertConsistency(myChildren, ignoreCase);
+    addToAdoptedChildren(name, ignoreCase);
+    assertConsistency(myChildren, ignoreCase, file);
   }
 
   private static final int CHILDREN_CACHED = 0x08;
@@ -608,7 +628,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
 
   @NotNull
   public synchronized List<String> getSuspiciousNames() {
-    List<VirtualFile> suspicious = new SubList<VirtualFile>(myChildren, getSuspiciousArrayStart(), myChildren.length);
+    List<VirtualFile> suspicious = new SubList<VirtualFile>(myChildren, getAdoptedChildrenStart(), myChildren.length);
     return ContainerUtil.map2List(suspicious, new Function<VirtualFile, String>() {
       @Override
       public String fun(VirtualFile file) {
@@ -617,17 +637,17 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
     });
   }
 
-  private int getSuspiciousArrayStart() {
+  private int getAdoptedChildrenStart() {
     int index = binSearch(myChildren, 0, myChildren.length, new Comparer() {
       @Override
       public int compareMyKeyTo(@NotNull VirtualFileSystemEntry v) {
-        return isSuspiciousName(v) ? -1 : 1;
+        return isAdoptedChild(v) ? -1 : 1;
       }
     });
     return -index - 1;
   }
 
-  private static boolean isSuspiciousName(@NotNull VirtualFileSystemEntry v) {
+  private static boolean isAdoptedChild(@NotNull VirtualFileSystemEntry v) {
     return v.getParent() == NULL_VIRTUAL_FILE;
   }
 
@@ -667,7 +687,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
   @Override
   @NotNull
   public synchronized List<VirtualFile> getCachedChildren() {
-    return new SubList<VirtualFile>(myChildren, 0, getSuspiciousArrayStart());
+    return new SubList<VirtualFile>(myChildren, 0, getAdoptedChildrenStart());
   }
 
   @Override
@@ -690,7 +710,7 @@ public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
   // optimisation: do not travel up unnecessary
   private void markDirtyRecursivelyInternal() {
     for (VirtualFileSystemEntry child : getArraySafely()) {
-      if (isSuspiciousName(child)) break;
+      if (isAdoptedChild(child)) break;
       child.markDirtyInternal();
       if (child instanceof VirtualDirectoryImpl) {
         ((VirtualDirectoryImpl)child).markDirtyRecursivelyInternal();
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/FSRecords.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/FSRecords.java
index d654209c37b3..df0bae9a543a 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/FSRecords.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/FSRecords.java
@@ -798,6 +798,11 @@ public class FSRecords implements Forceable {
       this.id = id;
       this.name = name;
     }
+
+    @Override
+    public String toString() {
+      return name + " (" + id + ")";
+    }
   }
 
   @NotNull

From 351313300dab8ec9caaed6a2f81b541279a90f11 Mon Sep 17 00:00:00 2001
From: Alexander Doroshko <alexander.doroshko@jetbrains.com>
Date: Tue, 26 Feb 2013 14:46:13 +0400
Subject: [PATCH 184/354] FlexUnit external compilation fixed

---
 .../impl/src/com/intellij/compiler/server/BuildManager.java  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
index e16b3d91c4c1..019131d051b8 100644
--- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
+++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
@@ -123,7 +123,8 @@ public class BuildManager implements ApplicationComponent{
 
   private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.server.BuildManager");
   private static final String COMPILER_PROCESS_JDK_PROPERTY = "compiler.process.jdk";
-  private static final String SYSTEM_ROOT = "compile-server";
+  public static final String SYSTEM_ROOT = "compile-server";
+  public static final String TEMP_DIR_NAME = "_temp_";
   private static final String LOGGER_CONFIG = "log.xml";
   private static final String DEFAULT_LOGGER_CONFIG = "defaultLogConfig.xml";
   private static final int MAKE_TRIGGER_DELAY = 300 /*300 ms*/;
@@ -877,7 +878,7 @@ public class BuildManager implements ApplicationComponent{
     workDirectory.mkdirs();
     ensureLogConfigExists(workDirectory);
 
-    cmdLine.addParameter("-Djava.io.tmpdir=" + FileUtil.toSystemIndependentName(workDirectory.getPath()) + "/_temp_");
+    cmdLine.addParameter("-Djava.io.tmpdir=" + FileUtil.toSystemIndependentName(workDirectory.getPath()) + "/" + TEMP_DIR_NAME);
 
     final List<String> cp = ClasspathBootstrap.getBuildProcessApplicationClasspath();
     cp.add(compilerPath);

From c4af63272c27797efc66a5b12f785bd24f2a2967 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Tue, 26 Feb 2013 14:55:59 +0400
Subject: [PATCH 185/354] IDEA-101881 Groovy: complete 'else'

---
 .../lang/completion/GroovyCompletionData.java |  7 ++++
 .../completion/KeywordCompletionTest.groovy   |  2 ++
 .../groovy/oldCompletion/keyword/else1.test   | 11 ++++++
 .../groovy/oldCompletion/keyword/else2.test   | 35 +++++++++++++++++++
 4 files changed, 55 insertions(+)
 create mode 100644 plugins/groovy/testdata/groovy/oldCompletion/keyword/else1.test
 create mode 100644 plugins/groovy/testdata/groovy/oldCompletion/keyword/else2.test

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java
index c16666f5faa5..6fbccb0b69f8 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java
@@ -516,6 +516,13 @@ public class GroovyCompletionData {
         nearestLeftSibling(context.getParent()) instanceof GrIfStatement) {
       return true;
     }
+
+    if (context.getParent() != null &&
+        nearestLeftSibling(context.getParent()) instanceof PsiErrorElement &&
+        nearestLeftSibling(nearestLeftSibling(context.getParent())) instanceof GrIfStatement) {
+      return true;
+    }
+
     if (context.getParent() != null &&
         nearestLeftSibling(context) != null &&
         nearestLeftSibling(context).getPrevSibling() instanceof GrIfStatement) {
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/KeywordCompletionTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/KeywordCompletionTest.groovy
index 02a4094c8841..5bdf156abd1e 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/KeywordCompletionTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/KeywordCompletionTest.groovy
@@ -100,6 +100,8 @@ public class KeywordCompletionTest extends CompletionTestBase {
   void testAnnotationArg()       { doTest() }
   void testDefaultAnnotationArg(){ doTest() }
   void testDefaultInAnnotation() { doTest() }
+  void testElse1()               { doTest() }
+  void testElse2()               { doTest() }
 
   String basePath = TestUtils.testDataPath + 'groovy/oldCompletion/keyword'
 
diff --git a/plugins/groovy/testdata/groovy/oldCompletion/keyword/else1.test b/plugins/groovy/testdata/groovy/oldCompletion/keyword/else1.test
new file mode 100644
index 000000000000..f2a1cd4929a6
--- /dev/null
+++ b/plugins/groovy/testdata/groovy/oldCompletion/keyword/else1.test
@@ -0,0 +1,11 @@
+class BaseLineService {
+    def service() {
+        if (true) {
+
+        } el<caret>
+    }
+}
+
+String abc = 5
+-----
+else
\ No newline at end of file
diff --git a/plugins/groovy/testdata/groovy/oldCompletion/keyword/else2.test b/plugins/groovy/testdata/groovy/oldCompletion/keyword/else2.test
new file mode 100644
index 000000000000..e95f662817d1
--- /dev/null
+++ b/plugins/groovy/testdata/groovy/oldCompletion/keyword/else2.test
@@ -0,0 +1,35 @@
+class BaseLineService {
+    def service() {
+        if (true) {
+
+        } <caret>
+    }
+}
+
+String abc = 5
+-----
+as
+assert
+boolean
+byte
+char
+double
+else
+false
+float
+for
+int
+long
+new
+null
+return
+short
+super
+switch
+synchronized
+this
+throw
+true
+try
+void
+while
\ No newline at end of file

From 3237767e35a99a37e85ba0753ff2fffdd7c6ce0b Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 13:01:04 +0400
Subject: [PATCH 186/354] cleanup

---
 .../resolve/reference/impl/providers/FileReferenceSet.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/FileReferenceSet.java b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/FileReferenceSet.java
index ddaad2c5973d..5a42c4244984 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/FileReferenceSet.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/impl/providers/FileReferenceSet.java
@@ -19,9 +19,10 @@ package com.intellij.psi.impl.source.resolve.reference.impl.providers;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleUtil;
+import com.intellij.openapi.module.ModuleUtilCore;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.Conditions;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
@@ -392,7 +393,7 @@ public class FileReferenceSet {
     }
     final Project project = file.getProject();
     PsiDirectory parent = file.getParent();
-    final Module module = ModuleUtil.findModuleForPsiElement(parent == null ? file : parent);
+    final Module module = ModuleUtilCore.findModuleForPsiElement(parent == null ? file : parent);
     if (module == null) {
       return Collections.emptyList();
     }
@@ -415,7 +416,7 @@ public class FileReferenceSet {
   }
 
   protected Condition<PsiFileSystemItem> getReferenceCompletionFilter() {
-    return Condition.TRUE;
+    return Conditions.alwaysTrue();
   }
 
   public <Option> void addCustomization(CustomizableReferenceProvider.CustomizationKey<Option> key, Option value) {

From 5b8690fdef7666f5be74f266111051a8a43f5a32 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 13:21:34 +0400
Subject: [PATCH 187/354] cleanup

---
 .../testFramework/fixtures/CodeInsightTestFixture.java        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/testFramework/src/com/intellij/testFramework/fixtures/CodeInsightTestFixture.java b/platform/testFramework/src/com/intellij/testFramework/fixtures/CodeInsightTestFixture.java
index 1e6cd3107a89..b30927a91748 100644
--- a/platform/testFramework/src/com/intellij/testFramework/fixtures/CodeInsightTestFixture.java
+++ b/platform/testFramework/src/com/intellij/testFramework/fixtures/CodeInsightTestFixture.java
@@ -133,7 +133,7 @@ public interface CodeInsightTestFixture extends IdeaProjectTestFixture {
    * @param file path to the file, relative to the testdata path.
    * @return the PSI file for the copied and opened file.
    */
-  PsiFile configureByFile(@TestDataFile @NonNls String file);
+  PsiFile configureByFile(@TestDataFile @NonNls String filePath);
 
   /**
    * Copies multiple files from the testdata directory to the same relative paths in the test project directory
@@ -142,7 +142,7 @@ public interface CodeInsightTestFixture extends IdeaProjectTestFixture {
    * @param files path to the files, relative to the testdata path.
    * @return the PSI files for the copied files.
    */
-  PsiFile[] configureByFiles(@TestDataFile @NonNls String... files);
+  PsiFile[] configureByFiles(@TestDataFile @NonNls String... filePaths);
 
   /**
    * Loads the specified text, treated as the contents of a file with the specified file type, into the in-memory

From 58aabfed671797bcea66a808895868f081cb181b Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Tue, 26 Feb 2013 15:28:03 +0400
Subject: [PATCH 188/354] IDEA-94776 Run tool window: local server: pinned tab
 is not reused on Rerun and Restart server

---
 .../src/com/intellij/execution/ExecutionManager.java     | 1 -
 .../intellij/execution/impl/ExecutionManagerImpl.java    | 1 -
 .../com/intellij/execution/ui/RunContentManagerImpl.java | 9 +++++----
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/execution/ExecutionManager.java b/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
index 1979a7d123b3..e51b46d73805 100644
--- a/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
+++ b/platform/lang-api/src/com/intellij/execution/ExecutionManager.java
@@ -48,7 +48,6 @@ public abstract class ExecutionManager {
                                        @NotNull Executor executor,
                                        @NotNull ExecutionEnvironment env);
 
-  @Deprecated
   public abstract void restartRunProfile(@NotNull Project project,
                                          @NotNull Executor executor,
                                          @NotNull ExecutionTarget target,
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
index 62873194e340..9d675ecdc65e 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
@@ -257,7 +257,6 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
   }
 
   @Override
-  @Deprecated
   public void restartRunProfile(@NotNull final Project project,
                                 @NotNull final Executor executor,
                                 @NotNull final ExecutionTarget target,
diff --git a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
index e64ab5d29bf6..22dc56c8c531 100644
--- a/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/ui/RunContentManagerImpl.java
@@ -391,8 +391,8 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
   }
 
   @Nullable
-  private static RunContentDescriptor chooseReuseContentForDescriptor(final ContentManager contentManager,
-                                                                      final RunContentDescriptor descriptor,
+  private static RunContentDescriptor chooseReuseContentForDescriptor(@NotNull ContentManager contentManager,
+                                                                      @Nullable RunContentDescriptor descriptor,
                                                                       long executionId,
                                                                       @Nullable String preferredName) {
     Content content = null;
@@ -403,7 +403,7 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
       }
       //Stage two: try to get content from descriptor itself
       final Content attachedContent = descriptor.getAttachedContent();
-      if (attachedContent != null && attachedContent.isValid()) content = attachedContent;
+      if (attachedContent != null && attachedContent.isValid() && contentManager.getIndexOfContent(attachedContent) != -1) content = attachedContent;
     }
     //Stage three: choose the content with name we prefer
     if (content == null) {
@@ -437,9 +437,10 @@ public class RunContentManagerImpl implements RunContentManager, Disposable {
         return c;
       }
     }
-    return preferredName != null ? getContentFromManager(contentManager, null, executionId) : null;
+    return preferredName != null  && !contents.isEmpty() ? getContentFromManager(contentManager, null, executionId) : null;
   }
 
+  @NotNull
   private ContentManager getContentManagerForRunner(final Executor executor) {
     final ContentManager contentManager = myToolwindowIdToContentManagerMap.get(executor.getToolWindowId());
     if (contentManager == null) {

From f80a433f12c046479fba9d3e655d5402111c27ba Mon Sep 17 00:00:00 2001
From: Alexander Lobas <Alexander.Lobas@jetbrains.com>
Date: Tue, 26 Feb 2013 16:20:16 +0400
Subject: [PATCH 189/354] IDEA-90621

---
 .../uiDesigner/lw/CompiledClassPropertiesProvider.java       | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/java/compiler/forms-compiler/src/com/intellij/uiDesigner/lw/CompiledClassPropertiesProvider.java b/java/compiler/forms-compiler/src/com/intellij/uiDesigner/lw/CompiledClassPropertiesProvider.java
index bea75bb87c6f..7c51f93eef14 100644
--- a/java/compiler/forms-compiler/src/com/intellij/uiDesigner/lw/CompiledClassPropertiesProvider.java
+++ b/java/compiler/forms-compiler/src/com/intellij/uiDesigner/lw/CompiledClassPropertiesProvider.java
@@ -73,13 +73,14 @@ public final class CompiledClassPropertiesProvider implements PropertiesProvider
 
       final Method readMethod = descriptor.getReadMethod();
       final Method writeMethod = descriptor.getWriteMethod();
-      if (writeMethod == null || readMethod == null) {
+      final Class propertyType = descriptor.getPropertyType();
+      if (writeMethod == null || readMethod == null || propertyType == null) {
         continue;
       }
 
       final String name = descriptor.getName();
 
-      final LwIntrospectedProperty property = propertyFromClass(descriptor.getPropertyType(), name);
+      final LwIntrospectedProperty property = propertyFromClass(propertyType, name);
 
       if (property != null) {
         property.setDeclaringClassName(descriptor.getReadMethod().getDeclaringClass().getName());

From ef69feb93d5e6af84fff2792cf7b5436ed70cf6b Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Tue, 26 Feb 2013 16:38:43 +0400
Subject: [PATCH 190/354] IDEA-101631 Updating Maven snapshots with sources
 does not synchronize sources to latest when navigating to class Fix tests.

---
 .../maven/importing/MavenRootModelAdapter.java    | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
index 6aaf850d5d28..614dbce63f96 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
@@ -327,24 +327,15 @@ public class MavenRootModelAdapter {
     String newUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, newPath) + JarFileSystem.JAR_SEPARATOR;
     for (String url : library.getUrls(type)) {
       if (newUrl.equals(url)) return;
-      if (clearAll || isRepositoryUrl(artifact, url, classifier, extension)) {
+      if (clearAll || isRepositoryUrl(artifact, url)) {
         library.removeRoot(url, type);
       }
     }
     library.addRoot(newUrl, type);
   }
 
-  private static boolean isRepositoryUrl(MavenArtifact artifact, String url, @Nullable String classifier, @Nullable String extension) {
-    if (!url.contains(artifact.getGroupId() + '/' + artifact.getArtifactId() + '/' + artifact.getBaseVersion() + '/' + artifact.getArtifactId() + '-')) {
-      return false;
-    }
-
-    String fileName = artifact.getFileNameWithBaseVersion(classifier, extension);
-    assert StringUtil.startsWithConcatenationOf(fileName, artifact.getArtifactId(), "-", artifact.getVersion());
-
-    String suffix = fileName.substring(artifact.getArtifactId().length() + 1 + artifact.getVersion().length());
-
-    return StringUtil.trimEnd(url, "!/").endsWith(suffix);
+  private static boolean isRepositoryUrl(MavenArtifact artifact, String url) {
+    return url.contains(artifact.getGroupId().replace('.', '/') + '/' + artifact.getArtifactId() + '/' + artifact.getBaseVersion() + '/' + artifact.getArtifactId() + '-');
   }
 
   public static boolean isChangedByUser(Library library) {

From fc6d77cbc5b67532dbfb5cc7161bf567d8c0db18 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 11:30:10 +0100
Subject: [PATCH 191/354] Don't write empty strings to index

---
 .../JavaClassReferenceListElementType.java    | 135 +++++++++---------
 1 file changed, 65 insertions(+), 70 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaClassReferenceListElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaClassReferenceListElementType.java
index 0f5befaa9ec7..ac54dad9be11 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaClassReferenceListElementType.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaClassReferenceListElementType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -18,6 +18,7 @@ package com.intellij.psi.impl.java.stubs;
 import com.intellij.lang.ASTNode;
 import com.intellij.lang.LighterAST;
 import com.intellij.lang.LighterASTNode;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiNameHelper;
 import com.intellij.psi.PsiReferenceList;
 import com.intellij.psi.impl.java.stubs.impl.PsiClassReferenceListStubImpl;
@@ -48,54 +49,29 @@ public abstract class JavaClassReferenceListElementType extends JavaStubElementT
   }
 
   @Override
-  public PsiReferenceList createPsi(@NotNull final PsiClassReferenceListStub stub) {
+  public PsiReferenceList createPsi(@NotNull PsiClassReferenceListStub stub) {
     return getPsiFactory(stub).createClassReferenceList(stub);
   }
 
   @Override
-  public PsiReferenceList createPsi(@NotNull final ASTNode node) {
+  public PsiReferenceList createPsi(@NotNull ASTNode node) {
     if (node.getElementType() == JavaStubElementTypes.EXTENDS_BOUND_LIST) {
       return new PsiTypeParameterExtendsBoundsListImpl(node);
     }
-    
-    return new PsiReferenceListImpl(node);
+    else {
+      return new PsiReferenceListImpl(node);
+    }
   }
 
   @Override
-  public PsiClassReferenceListStub createStub(final LighterAST tree,
-                                              final LighterASTNode node,
-                                              final StubElement parentStub) {
-    final JavaClassReferenceListElementType type = (JavaClassReferenceListElementType)node.getTokenType();
+  public PsiClassReferenceListStub createStub(LighterAST tree, LighterASTNode node, StubElement parentStub) {
+    JavaClassReferenceListElementType type = (JavaClassReferenceListElementType)node.getTokenType();
     return new PsiClassReferenceListStubImpl(type, parentStub, getTexts(tree, node), elementTypeToRole(type));
   }
 
-  private static JavaClassReferenceListElementType roleToElementType(final PsiReferenceList.Role role) {
-    switch (role) {
-      case EXTENDS_BOUNDS_LIST:
-        return JavaStubElementTypes.EXTENDS_BOUND_LIST;
-      case EXTENDS_LIST:
-        return JavaStubElementTypes.EXTENDS_LIST;
-      case IMPLEMENTS_LIST:
-        return JavaStubElementTypes.IMPLEMENTS_LIST;
-      case THROWS_LIST:
-        return JavaStubElementTypes.THROWS_LIST;
-    }
-
-    throw new RuntimeException("Unknown role: " + role);
-  }
-
-  private static PsiReferenceList.Role elementTypeToRole(final IElementType type) {
-    if (type == JavaStubElementTypes.EXTENDS_BOUND_LIST) return PsiReferenceList.Role.EXTENDS_BOUNDS_LIST;
-    else if (type == JavaStubElementTypes.EXTENDS_LIST) return PsiReferenceList.Role.EXTENDS_LIST;
-    else if (type == JavaStubElementTypes.IMPLEMENTS_LIST) return PsiReferenceList.Role.IMPLEMENTS_LIST;
-    else if (type == JavaStubElementTypes.THROWS_LIST) return PsiReferenceList.Role.THROWS_LIST;
-
-    throw new RuntimeException("Unknown element type: " + type);
-  }
-
-  private static String[] getTexts(final LighterAST tree, final LighterASTNode node) {
-    final List<LighterASTNode> refs = LightTreeUtil.getChildrenOfType(tree, node, JavaElementType.JAVA_CODE_REFERENCE);
-    final String[] texts = ArrayUtil.newStringArray(refs.size());
+  private static String[] getTexts(LighterAST tree, LighterASTNode node) {
+    List<LighterASTNode> refs = LightTreeUtil.getChildrenOfType(tree, node, JavaElementType.JAVA_CODE_REFERENCE);
+    String[] texts = ArrayUtil.newStringArray(refs.size());
     for (int i = 0; i < refs.size(); i++) {
       texts[i] = LightTreeUtil.toFilteredString(tree, refs.get(i), null);
     }
@@ -103,9 +79,11 @@ public abstract class JavaClassReferenceListElementType extends JavaStubElementT
   }
 
   @Override
-  public void serialize(final PsiClassReferenceListStub stub, final StubOutputStream dataStream) throws IOException {
-    dataStream.writeByte(encodeRole(stub.getRole()));
-    final String[] names = stub.getReferencedNames();
+  public void serialize(PsiClassReferenceListStub stub, StubOutputStream dataStream) throws IOException {
+    byte role = encodeRole(stub.getRole());
+    dataStream.writeByte(role);
+
+    String[] names = stub.getReferencedNames();
     dataStream.writeVarInt(names.length);
     for (String name : names) {
       dataStream.writeName(name);
@@ -113,49 +91,29 @@ public abstract class JavaClassReferenceListElementType extends JavaStubElementT
   }
 
   @Override
-  public PsiClassReferenceListStub deserialize(final StubInputStream dataStream, final StubElement parentStub) throws IOException {
+  public PsiClassReferenceListStub deserialize(StubInputStream dataStream, StubElement parentStub) throws IOException {
     byte role = dataStream.readByte();
+
     int len = dataStream.readVarInt();
     StringRef[] names = StringRef.createArray(len);
     for (int i = 0; i < names.length; i++) {
       names[i] = dataStream.readName();
     }
 
-    final PsiReferenceList.Role decodedRole = decodeRole(role);
+    PsiReferenceList.Role decodedRole = decodeRole(role);
     return new PsiClassReferenceListStubImpl(roleToElementType(decodedRole), parentStub, names, decodedRole);
   }
 
-  private static PsiReferenceList.Role decodeRole(int code) {
-    switch (code) {
-      case 0: return PsiReferenceList.Role.EXTENDS_LIST;
-      case 1: return PsiReferenceList.Role.IMPLEMENTS_LIST;
-      case 2: return PsiReferenceList.Role.THROWS_LIST;
-      case 3: return PsiReferenceList.Role.EXTENDS_BOUNDS_LIST;
-
-      default:
-        throw new RuntimeException("Unknown role code: " + code);
-    }
-  }
-
-  private static byte encodeRole(PsiReferenceList.Role role) {
-    switch (role) {
-      case EXTENDS_LIST:         return 0;
-      case IMPLEMENTS_LIST:      return 1;
-      case THROWS_LIST:          return 2;
-      case EXTENDS_BOUNDS_LIST:  return 3;
-
-      default:
-        throw new RuntimeException("Unknown role code: " + role);
-    }
-  }
-
   @Override
-  public void indexStub(final PsiClassReferenceListStub stub, final IndexSink sink) {
-    final PsiReferenceList.Role role = stub.getRole();
+  public void indexStub(PsiClassReferenceListStub stub, IndexSink sink) {
+    PsiReferenceList.Role role = stub.getRole();
     if (role == PsiReferenceList.Role.EXTENDS_LIST || role == PsiReferenceList.Role.IMPLEMENTS_LIST) {
-      final String[] names = stub.getReferencedNames();
+      String[] names = stub.getReferencedNames();
       for (String name : names) {
-        sink.occurrence(JavaStubIndexKeys.SUPER_CLASSES, PsiNameHelper.getShortClassName(name));
+        String shortName = PsiNameHelper.getShortClassName(name);
+        if (!StringUtil.isEmptyOrSpaces(shortName)) {
+          sink.occurrence(JavaStubIndexKeys.SUPER_CLASSES, shortName);
+        }
       }
 
       if (role == PsiReferenceList.Role.EXTENDS_LIST) {
@@ -165,7 +123,6 @@ public abstract class JavaClassReferenceListElementType extends JavaStubElementT
           if (psiClassStub.isEnum()) {
             sink.occurrence(JavaStubIndexKeys.SUPER_CLASSES, "Enum");
           }
-
           if (psiClassStub.isAnnotationType()) {
             sink.occurrence(JavaStubIndexKeys.SUPER_CLASSES, "Annotation");
           }
@@ -173,4 +130,42 @@ public abstract class JavaClassReferenceListElementType extends JavaStubElementT
       }
     }
   }
+
+  private static PsiReferenceList.Role elementTypeToRole(IElementType type) {
+    if (type == JavaStubElementTypes.EXTENDS_BOUND_LIST) return PsiReferenceList.Role.EXTENDS_BOUNDS_LIST;
+    else if (type == JavaStubElementTypes.EXTENDS_LIST) return PsiReferenceList.Role.EXTENDS_LIST;
+    else if (type == JavaStubElementTypes.IMPLEMENTS_LIST) return PsiReferenceList.Role.IMPLEMENTS_LIST;
+    else if (type == JavaStubElementTypes.THROWS_LIST) return PsiReferenceList.Role.THROWS_LIST;
+    throw new RuntimeException("Unknown element type: " + type);
+  }
+
+  private static JavaClassReferenceListElementType roleToElementType(PsiReferenceList.Role role) {
+    switch (role) {
+      case EXTENDS_BOUNDS_LIST: return JavaStubElementTypes.EXTENDS_BOUND_LIST;
+      case EXTENDS_LIST:        return JavaStubElementTypes.EXTENDS_LIST;
+      case IMPLEMENTS_LIST:     return JavaStubElementTypes.IMPLEMENTS_LIST;
+      case THROWS_LIST:         return JavaStubElementTypes.THROWS_LIST;
+    }
+    throw new RuntimeException("Unknown role: " + role);
+  }
+
+  private static byte encodeRole(PsiReferenceList.Role role) {
+    switch (role) {
+      case EXTENDS_LIST:        return 0;
+      case IMPLEMENTS_LIST:     return 1;
+      case THROWS_LIST:         return 2;
+      case EXTENDS_BOUNDS_LIST: return 3;
+    }
+    throw new RuntimeException("Unknown role: " + role);
+  }
+
+  private static PsiReferenceList.Role decodeRole(byte code) {
+    switch (code) {
+      case 0: return PsiReferenceList.Role.EXTENDS_LIST;
+      case 1: return PsiReferenceList.Role.IMPLEMENTS_LIST;
+      case 2: return PsiReferenceList.Role.THROWS_LIST;
+      case 3: return PsiReferenceList.Role.EXTENDS_BOUNDS_LIST;
+    }
+    throw new RuntimeException("Unknown role code: " + code);
+  }
 }

From 357ef16a6435a108b363064a47a8d8a908f56a1c Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 12:40:10 +0100
Subject: [PATCH 192/354] EA-44191 (diagnostic)

---
 .../src/com/intellij/openapi/util/io/win32/IdeaWin32.java   | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java b/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java
index 469bc0f08503..f06c69921b31 100644
--- a/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java
+++ b/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -23,6 +23,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.FileNotFoundException;
+import java.util.Arrays;
 
 /**
  * Do not use this class directly.
@@ -47,7 +48,8 @@ public class IdeaWin32 {
           if (!new File(path).exists()) {
             path = PathManager.getHomePath() + "/bin/win/" + libName + ".dll";
             if (!new File(path).exists()) {
-              throw new FileNotFoundException("Native filesystem .dll is missing, home: " + PathManager.getHomePath());
+              throw new FileNotFoundException("Native filesystem .dll is missing (path=" + PathManager.getBinPath() +
+                                              " content=" + Arrays.toString(new File(PathManager.getBinPath()).list()) + ")");
             }
           }
         }

From 5c9c590d06e0d529d1111aedc329ceaca3db770b Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 13:56:45 +0100
Subject: [PATCH 193/354] Obsolete class deprecated

---
 .../MethodBodyChecker.java                         |  7 +++----
 .../java/stubs/impl/PsiAnnotationStubImpl.java     |  9 ++++-----
 .../stubs/impl/PsiImportStatementStubImpl.java     |  8 ++++----
 .../psi/impl/source/PsiAnnotationMethodImpl.java   |  8 ++++----
 .../psi/impl/source/PsiAnonymousClassImpl.java     |  8 ++++----
 .../com/intellij/psi/impl/source/PsiFieldImpl.java | 12 ++++++------
 .../intellij/psi/impl/source/PsiMethodImpl.java    | 10 +++++-----
 .../intellij/psi/impl/source/PsiParameterImpl.java |  8 ++++----
 .../psi/impl/source/PsiTypeElementImpl.java        | 14 +++++++-------
 .../com/intellij/psi/impl/source/PsiFileImpl.java  |  3 +--
 .../com/intellij/util/PatchedSoftReference.java    |  4 +++-
 11 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInspection/defaultFileTemplateUsage/MethodBodyChecker.java b/java/java-impl/src/com/intellij/codeInspection/defaultFileTemplateUsage/MethodBodyChecker.java
index 5ee8cadb7ffd..d379a9f8e079 100644
--- a/java/java-impl/src/com/intellij/codeInspection/defaultFileTemplateUsage/MethodBodyChecker.java
+++ b/java/java-impl/src/com/intellij/codeInspection/defaultFileTemplateUsage/MethodBodyChecker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -33,7 +33,6 @@ 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;
@@ -82,7 +81,7 @@ public class MethodBodyChecker {
     SoftReference<Map<String, PsiMethod>> ref = aClass.getUserData(CACHE_KEY);
     Map<String, PsiMethod> cache = ref == null ? null : ref.get();
     if (cache == null) {
-      aClass.putUserData(CACHE_KEY, new PatchedSoftReference<Map<String, PsiMethod>>(cache = new ConcurrentHashMap<String, PsiMethod>()));
+      aClass.putUserData(CACHE_KEY, new SoftReference<Map<String, PsiMethod>>(cache = new ConcurrentHashMap<String, PsiMethod>()));
     }
     return cache;
   }
@@ -107,7 +106,7 @@ public class MethodBodyChecker {
 
     if (PsiEquivalenceUtil.areElementsEquivalent(body, templateBody, new Comparator<PsiElement>(){
       public int compare(final PsiElement element1, final PsiElement element2) {
-        // templates may be different on super method name                              
+        // templates may be different on super method name
         if (element1 == superMethod && (element2 == templateMethod || element2 == null)) return 0;
         return 1;
       }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiAnnotationStubImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiAnnotationStubImpl.java
index ed0b25bf2dbc..0f677e127aee 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiAnnotationStubImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiAnnotationStubImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -24,8 +24,8 @@ import com.intellij.psi.impl.java.stubs.JavaStubElementTypes;
 import com.intellij.psi.impl.java.stubs.PsiAnnotationStub;
 import com.intellij.psi.stubs.StubBase;
 import com.intellij.psi.stubs.StubElement;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 
@@ -38,7 +38,7 @@ public class PsiAnnotationStubImpl extends StubBase<PsiAnnotation> implements Ps
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.java.stubs.impl.PsiAnnotationStubImpl");
 
   private final String myText;
-  private PatchedSoftReference<PsiAnnotation> myParsedFromRepository;
+  private SoftReference<PsiAnnotation> myParsedFromRepository;
 
   public PsiAnnotationStubImpl(final StubElement parent, final String text) {
     this(parent, text, null);
@@ -73,8 +73,7 @@ public class PsiAnnotationStubImpl extends StubBase<PsiAnnotation> implements Ps
     try {
       PsiJavaParserFacade facade = JavaPsiFacade.getInstance(getProject()).getParserFacade();
       PsiAnnotation annotation = facade.createAnnotationFromText(text, getPsi());
-      myParsedFromRepository = new PatchedSoftReference<PsiAnnotation>(annotation);
-      assert annotation != null : text;
+      myParsedFromRepository = new SoftReference<PsiAnnotation>(annotation);
       return annotation;
     }
     catch (IncorrectOperationException e) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiImportStatementStubImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiImportStatementStubImpl.java
index 995aafcc66dc..6a217d3466c0 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiImportStatementStubImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiImportStatementStubImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -28,15 +28,15 @@ import com.intellij.psi.impl.java.stubs.PsiImportStatementStub;
 import com.intellij.psi.impl.source.PsiJavaCodeReferenceElementImpl;
 import com.intellij.psi.stubs.StubBase;
 import com.intellij.psi.stubs.StubElement;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 
 public class PsiImportStatementStubImpl extends StubBase<PsiImportStatementBase> implements PsiImportStatementStub {
   private final byte myFlags;
   private final StringRef myText;
-  private PatchedSoftReference<PsiJavaCodeReferenceElement> myReference = null;
+  private SoftReference<PsiJavaCodeReferenceElement> myReference = null;
 
   private final static int ON_DEMAND = 0x01;
   private final static int STATIC = 0x02;
@@ -80,7 +80,7 @@ public class PsiImportStatementStubImpl extends StubBase<PsiImportStatementBase>
     PsiJavaCodeReferenceElement ref = myReference != null ? myReference.get() : null;
     if (ref == null) {
       ref = isStatic() ? getStaticReference() : getRegularReference();
-      myReference = new PatchedSoftReference<PsiJavaCodeReferenceElement>(ref);
+      myReference = new SoftReference<PsiJavaCodeReferenceElement>(ref);
     }
     return ref;
   }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnnotationMethodImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnnotationMethodImpl.java
index 0dcef9eefd57..70229d13e67b 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnnotationMethodImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnnotationMethodImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -22,7 +22,7 @@ import com.intellij.psi.*;
 import com.intellij.psi.impl.java.stubs.JavaStubElementTypes;
 import com.intellij.psi.impl.java.stubs.PsiMethodStub;
 import com.intellij.psi.impl.source.tree.ChildRole;
-import com.intellij.util.PatchedSoftReference;
+import com.intellij.reference.SoftReference;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
@@ -30,7 +30,7 @@ import org.jetbrains.annotations.NotNull;
  * @author ven
  */
 public class PsiAnnotationMethodImpl extends PsiMethodImpl implements PsiAnnotationMethod {
-  private PatchedSoftReference<PsiAnnotationMemberValue> myCachedDefaultValue = null;
+  private SoftReference<PsiAnnotationMemberValue> myCachedDefaultValue = null;
 
   public PsiAnnotationMethodImpl(final PsiMethodStub stub) {
     super(stub, JavaStubElementTypes.ANNOTATION_METHOD);
@@ -68,7 +68,7 @@ public class PsiAnnotationMethodImpl extends PsiMethodImpl implements PsiAnnotat
       final PsiFileFactory factory = PsiFileFactory.getInstance(getProject());
       final PsiJavaFile file = (PsiJavaFile)factory.createFileFromText("a.java", JavaFileType.INSTANCE, annoText);
       final PsiAnnotationMemberValue value = ((PsiAnnotationMethod)file.getClasses()[0].getMethods()[0]).getDefaultValue();
-      myCachedDefaultValue = new PatchedSoftReference<PsiAnnotationMemberValue>(value);
+      myCachedDefaultValue = new SoftReference<PsiAnnotationMemberValue>(value);
       return value;
     }
 
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnonymousClassImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnonymousClassImpl.java
index 8038317d6c61..9d14b52babb6 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnonymousClassImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiAnonymousClassImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -22,12 +22,12 @@ import com.intellij.psi.impl.java.stubs.PsiClassStub;
 import com.intellij.psi.impl.source.tree.ChildRole;
 import com.intellij.psi.impl.source.tree.SharedImplUtil;
 import com.intellij.psi.scope.PsiScopeProcessor;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import org.jetbrains.annotations.NotNull;
 
 public class PsiAnonymousClassImpl extends PsiClassImpl implements PsiAnonymousClass {
-  private PatchedSoftReference<PsiClassType> myCachedBaseType = null;
+  private SoftReference<PsiClassType> myCachedBaseType = null;
 
   public PsiAnonymousClassImpl(final PsiClassStub stub) {
     super(stub, JavaStubElementTypes.ANONYMOUS_CLASS);
@@ -92,7 +92,7 @@ public class PsiAnonymousClassImpl extends PsiClassImpl implements PsiAnonymousC
         type = PsiType.getJavaLangObject(getManager(), getResolveScope());
       }
 
-      myCachedBaseType = new PatchedSoftReference<PsiClassType>(type);
+      myCachedBaseType = new SoftReference<PsiClassType>(type);
       return type;
     }
     else {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiFieldImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiFieldImpl.java
index c426d1a07a42..2d3d4356babe 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiFieldImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiFieldImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -33,9 +33,9 @@ import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.ui.RowIcon;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.PlatformIcons;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -49,7 +49,7 @@ import java.util.Set;
 public class PsiFieldImpl extends JavaStubPsiElement<PsiFieldStub> implements PsiField, PsiVariableEx, Queryable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.PsiFieldImpl");
 
-  private volatile PatchedSoftReference<PsiType> myCachedType = null;
+  private volatile SoftReference<PsiType> myCachedType = null;
   private volatile Object myCachedInitializerValue = null; // PsiExpression on constant value for literal
 
   public PsiFieldImpl(final PsiFieldStub stub) {
@@ -129,7 +129,7 @@ public class PsiFieldImpl extends JavaStubPsiElement<PsiFieldStub> implements Ps
       String typeText = TypeInfo.createTypeText(stub.getType(false));
       try {
         final PsiType type = JavaPsiFacade.getInstance(getProject()).getParserFacade().createTypeFromText(typeText, this);
-        myCachedType = new PatchedSoftReference<PsiType>(type);
+        myCachedType = new SoftReference<PsiType>(type);
         return type;
       }
       catch (IncorrectOperationException e) {
@@ -148,7 +148,7 @@ public class PsiFieldImpl extends JavaStubPsiElement<PsiFieldStub> implements Ps
   public PsiType getType(){
     final PsiFieldStub stub = getStub();
     if (stub != null) {
-      PatchedSoftReference<PsiType> cachedType = myCachedType;
+      SoftReference<PsiType> cachedType = myCachedType;
       if (cachedType != null) {
         PsiType type = cachedType.get();
         if (type != null) return type;
@@ -157,7 +157,7 @@ public class PsiFieldImpl extends JavaStubPsiElement<PsiFieldStub> implements Ps
       String typeText = TypeInfo.createTypeText(stub.getType(true));
       try {
         final PsiType type = JavaPsiFacade.getInstance(getProject()).getParserFacade().createTypeFromText(typeText, this);
-        myCachedType = new PatchedSoftReference<PsiType>(type);
+        myCachedType = new SoftReference<PsiType>(type);
         return type;
       }
       catch (IncorrectOperationException e) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiMethodImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiMethodImpl.java
index 06280bcce954..ee0cc0149ee0 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiMethodImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiMethodImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -40,9 +40,9 @@ import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.util.MethodSignature;
 import com.intellij.psi.util.MethodSignatureBackedByPsiMethod;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.ui.RowIcon;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.PlatformIcons;
 import org.jetbrains.annotations.NotNull;
 
@@ -53,7 +53,7 @@ import java.util.Map;
 public class PsiMethodImpl extends JavaStubPsiElement<PsiMethodStub> implements PsiMethod, Queryable {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.PsiMethodImpl");
 
-  private PatchedSoftReference<PsiType> myCachedType = null;
+  private SoftReference<PsiType> myCachedType = null;
 
   public PsiMethodImpl(final PsiMethodStub stub) {
     this(stub, JavaStubElementTypes.METHOD);
@@ -220,7 +220,7 @@ public class PsiMethodImpl extends JavaStubPsiElement<PsiMethodStub> implements
       final String typeText = TypeInfo.createTypeText(stub.getReturnTypeText(true));
       if (typeText == null) return null;
 
-      PatchedSoftReference<PsiType> cachedType = myCachedType;
+      SoftReference<PsiType> cachedType = myCachedType;
       if (cachedType != null) {
         PsiType type = cachedType.get();
         if (type != null) return type;
@@ -228,7 +228,7 @@ public class PsiMethodImpl extends JavaStubPsiElement<PsiMethodStub> implements
 
       try {
         final PsiType type = JavaPsiFacade.getInstance(getProject()).getElementFactory().createTypeFromText(typeText, this);
-        myCachedType = new PatchedSoftReference<PsiType>(type);
+        myCachedType = new SoftReference<PsiType>(type);
         return type;
       }
       catch (IncorrectOperationException e) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java
index 446f4ce06f6d..3635752250cf 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiParameterImpl.java
@@ -32,9 +32,9 @@ import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.ui.RowIcon;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.PlatformIcons;
 import org.jetbrains.annotations.NotNull;
 
@@ -44,7 +44,7 @@ import java.util.Arrays;
 public class PsiParameterImpl extends JavaStubPsiElement<PsiParameterStub> implements PsiParameter {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.PsiParameterImpl");
 
-  private volatile PatchedSoftReference<PsiType> myCachedType = null;
+  private volatile SoftReference<PsiType> myCachedType = null;
 
   public PsiParameterImpl(@NotNull PsiParameterStub stub) {
     this(stub, JavaStubElementTypes.PARAMETER);
@@ -116,7 +116,7 @@ public class PsiParameterImpl extends JavaStubPsiElement<PsiParameterStub> imple
   public PsiType getType() {
     PsiParameterStub stub = getStub();
     if (stub != null) {
-      PatchedSoftReference<PsiType> cachedType = myCachedType;
+      SoftReference<PsiType> cachedType = myCachedType;
       if (cachedType != null) {
         PsiType type = cachedType.get();
         if (type != null) return type;
@@ -126,7 +126,7 @@ public class PsiParameterImpl extends JavaStubPsiElement<PsiParameterStub> imple
       assert typeText != null : stub;
       try {
         PsiType type = JavaPsiFacade.getInstance(getProject()).getParserFacade().createTypeFromText(typeText, this);
-        myCachedType = new PatchedSoftReference<PsiType>(type);
+        myCachedType = new SoftReference<PsiType>(type);
         return type;
       }
       catch (IncorrectOperationException e) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiTypeElementImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiTypeElementImpl.java
index 517ea3197037..b4086db18569 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiTypeElementImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiTypeElementImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -28,9 +28,9 @@ import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.Function;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.SmartList;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NonNls;
@@ -45,7 +45,7 @@ public class PsiTypeElementImpl extends CompositePsiElement implements PsiTypeEl
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.PsiTypeElementImpl");
 
   private volatile PsiType myCachedType = null;
-  private volatile PatchedSoftReference<PsiType> myCachedDetachedType = null;
+  private volatile SoftReference<PsiType> myCachedDetachedType = null;
 
   @SuppressWarnings({"UnusedDeclaration"})
   public PsiTypeElementImpl() {
@@ -110,8 +110,8 @@ public class PsiTypeElementImpl extends CompositePsiElement implements PsiTypeEl
           final List<PsiType> types = ContainerUtil.map(typeElements, new Function<PsiTypeElement, PsiType>() {
               @Override public PsiType fun(final PsiTypeElement psiTypeElement) { return psiTypeElement.getType(); }
           });
-          cachedType = opElement instanceof PsiJavaToken && ((PsiJavaToken)opElement).getTokenType() == JavaTokenType.AND 
-                       ? PsiIntersectionType.createIntersection(types.toArray(new PsiType[types.size()])) 
+          cachedType = opElement instanceof PsiJavaToken && ((PsiJavaToken)opElement).getTokenType() == JavaTokenType.AND
+                       ? PsiIntersectionType.createIntersection(types.toArray(new PsiType[types.size()]))
                        : new PsiDisjunctionType(types, getManager());
         }
       }
@@ -168,14 +168,14 @@ public class PsiTypeElementImpl extends CompositePsiElement implements PsiTypeEl
   }
 
   public PsiType getDetachedType(@NotNull PsiElement context) {
-    PatchedSoftReference<PsiType> cached = myCachedDetachedType;
+    SoftReference<PsiType> cached = myCachedDetachedType;
     PsiType type = cached == null ? null : cached.get();
     if (type != null) return type;
     try {
       String combinedAnnotations = getCombinedAnnotationsText();
       String text = combinedAnnotations.isEmpty() ? getText().trim() : combinedAnnotations + " " + getText().trim();
       type = JavaPsiFacade.getInstance(getProject()).getElementFactory().createTypeFromText(text, context);
-      myCachedDetachedType = new PatchedSoftReference<PsiType>(type);
+      myCachedDetachedType = new SoftReference<PsiType>(type);
     }
     catch (IncorrectOperationException e) {
       return getType();
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
index 746e229bc258..7a2ba7eda4bd 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
@@ -58,7 +58,6 @@ import com.intellij.psi.tree.TokenSet;
 import com.intellij.reference.SoftReference;
 import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.PatchedWeakReference;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.text.CharArrayUtil;
@@ -723,7 +722,7 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
     }
     return myManager.isBatchFilesProcessingMode()
                  ? new PatchedWeakReference<ASTNode>(treeElement)
-                 : new PatchedSoftReference<ASTNode>(treeElement);
+                 : new SoftReference<ASTNode>(treeElement);
   }
 
   @Override
diff --git a/platform/core-impl/src/com/intellij/util/PatchedSoftReference.java b/platform/core-impl/src/com/intellij/util/PatchedSoftReference.java
index 61308bb38633..578f5c66f42b 100644
--- a/platform/core-impl/src/com/intellij/util/PatchedSoftReference.java
+++ b/platform/core-impl/src/com/intellij/util/PatchedSoftReference.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -19,6 +19,8 @@ import com.intellij.reference.SoftReference;
 
 import java.lang.ref.ReferenceQueue;
 
+/** @deprecated use {@link SoftReference} (to remove in IDEA 13) */
+@SuppressWarnings("UnusedDeclaration")
 public class PatchedSoftReference<T> extends SoftReference<T> {
   public PatchedSoftReference(final T referent) {
     super(referent);

From bdd49b2160719a9c7fe207a17ceeebb93e245150 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 13:56:53 +0100
Subject: [PATCH 194/354] Formatting

---
 .../intellij/psi/impl/cache/RecordUtil.java   |  4 ++--
 .../com/intellij/reference/SoftReference.java | 21 ++++++++++---------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
index 3e83c7a42329..a311b48a80dd 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
@@ -59,8 +59,8 @@ public class RecordUtil {
 
   public static boolean isDeprecatedByDocComment(@NotNull LighterAST tree, @NotNull LighterASTNode comment) {
     // todo[r.sh] parse doc comments, implement tree lookup
-    final String text = LightTreeUtil.toFilteredString(tree, comment, null);
-    return text != null && text.contains(DEPRECATED_TAG);
+    String text = LightTreeUtil.toFilteredString(tree, comment, null);
+    return text.contains(DEPRECATED_TAG);
   }
 
   public static int packModifierList(@NotNull LighterAST tree, @NotNull LighterASTNode modList, @NotNull StubElement parent) {
diff --git a/platform/util-rt/src/com/intellij/reference/SoftReference.java b/platform/util-rt/src/com/intellij/reference/SoftReference.java
index 209ec09c195f..ce74a7499b6c 100644
--- a/platform/util-rt/src/com/intellij/reference/SoftReference.java
+++ b/platform/util-rt/src/com/intellij/reference/SoftReference.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -21,24 +21,25 @@ import java.lang.ref.ReferenceQueue;
  * The class is necessary to debug memory allocations via soft references. All IDEA classes should use this SoftReference
  * instead of original from java.lang.ref. Whenever we suspect soft memory allocation overhead this easily becomes a hard
  * reference so we can see allocations and memory consumption in memory profiler.
+ *
  * @author max
  */
+@SuppressWarnings("ClassNameSameAsAncestorName")
 public class SoftReference<T> extends java.lang.ref.SoftReference<T> {
-//  T myReferent;
+  //private final T myReferent;
+
   public SoftReference(final T referent) {
     super(referent);
-//    myReferent = referent;
+    //myReferent = referent;
   }
 
   public SoftReference(final T referent, final ReferenceQueue<? super T> q) {
     super(referent, q);
-//    myReferent = referent;
+    //myReferent = referent;
   }
 
-  /*
-  @Override
-  public T get() {
-    return myReferent;
-  }
-  */
+  //@Override
+  //public T get() {
+  //  return myReferent;
+  //}
 }

From 95d75377012176f6e63867ce6089677efa7193f8 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 13:57:53 +0100
Subject: [PATCH 195/354] Class short name calculation fixed

---
 .../src/com/intellij/psi/PsiNameHelper.java   |   26 +-
 .../com/intellij/psi/PsiNameHelperTest.java   | 1207 +++++++++++++++++
 2 files changed, 1219 insertions(+), 14 deletions(-)
 create mode 100644 java/java-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java b/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java
index be0712efa5bc..e82221e7a887 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiNameHelper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -67,17 +67,12 @@ public abstract class PsiNameHelper {
 
   @NotNull
   public static String getShortClassName(@NotNull String referenceText) {
-    return getShortClassName(referenceText, true);
-  }
+    int lessPos = referenceText.length(), bracesBalance = 0, i;
 
-  private static String getShortClassName(String referenceText, boolean removeWhitespace) {
-    int lessPos = referenceText.length();
-    int bracesBalance = 0;
-    int i;
     loop:
     for (i = referenceText.length() - 1; i >= 0; i--) {
-      final char aChar = referenceText.charAt(i);
-      switch (aChar) {
+      char ch = referenceText.charAt(i);
+      switch (ch) {
         case ')':
         case '>':
           bracesBalance++;
@@ -91,22 +86,25 @@ public abstract class PsiNameHelper {
 
         case '@':
         case '.':
-          if (bracesBalance == 0) break loop;
+          if (bracesBalance <= 0) break loop;
           break;
 
         default:
-          if (bracesBalance == 0 && removeWhitespace && !Character.isWhitespace(aChar) && !Character.isJavaIdentifierPart(aChar)) {
-            return getShortClassName(removeWhitespace(referenceText), false);
+          if (Character.isWhitespace(ch) && bracesBalance <= 0) {
+            for (int j = i + 1; j < lessPos; j++) {
+              if (!Character.isWhitespace(referenceText.charAt(j))) break loop;
+            }
+            lessPos = i;
           }
       }
     }
+
     String sub = referenceText.substring(i + 1, lessPos).trim();
     return sub.length() == referenceText.length() ? sub : new String(sub);
   }
 
   public static String getPresentableText(PsiJavaCodeReferenceElement ref) {
     final String referenceName = ref.getReferenceName();
-
     PsiType[] typeParameters = ref.getTypeParameters();
     return getPresentableText(referenceName, typeParameters);
   }
@@ -167,7 +165,7 @@ public abstract class PsiNameHelper {
    * <code>["List&lt;String&gt","Integer"]</code>
    *
    * @param referenceText the text of the reference to calculate type parameters for.
-   * @return the calculated array of type parameters. 
+   * @return the calculated array of type parameters.
    */
   public static String[] getClassParametersText(String referenceText) {
     if (referenceText.indexOf('<') < 0) return ArrayUtil.EMPTY_STRING_ARRAY;
diff --git a/java/java-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java b/java/java-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java
new file mode 100644
index 000000000000..7be6c4a74498
--- /dev/null
+++ b/java/java-tests/testSrc/com/intellij/psi/PsiNameHelperTest.java
@@ -0,0 +1,1207 @@
+/*
+ * Copyright 2000-2013 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.psi;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class PsiNameHelperTest {
+  @Test
+  public void shortClassName() {
+    doTest("I<Integer>", "I");
+    doTest("I<Long>", "I");
+    doTest("java.lang.Object", "Object");
+    doTest("java.lang.String", "String");
+    doTest("java.lang.Throwable", "Throwable");
+    doTest("java.io.PrintStream", "PrintStream");
+    doTest("java.io.PrintWriter", "PrintWriter");
+    doTest("java.lang.StackTraceElement", "StackTraceElement");
+    doTest("java.lang.Throwable.PrintStreamOrWriter", "PrintStreamOrWriter");
+    doTest("java.io.ObjectInputStream", "ObjectInputStream");
+    doTest("java.io.ObjectOutputStream", "ObjectOutputStream");
+    doTest("java.lang.Integer", "Integer");
+    doTest("java.lang.Long", "Long");
+    doTest("java.lang.Error", "Error");
+    doTest("java.lang.RuntimeException", "RuntimeException");
+    doTest("@Override", "Override");
+    doTest("java.lang.annotation.Target", "Target");
+    doTest("java.net.MalformedURLException", "MalformedURLException");
+    doTest("java.io.IOException", "IOException");
+    doTest("java.net.URLConnection", "URLConnection");
+    doTest("java.io.InputStream", "InputStream");
+    doTest("java.lang.AutoCloseable", "AutoCloseable");
+    doTest("@", "");
+    doTest("@Deprecated", "Deprecated");
+    doTest("java.lang.annotation.Documented", "Documented");
+    doTest("java.lang.annotation.Retention", "Retention");
+    doTest("CSuperFoo<X>", "CSuperFoo");
+    doTest("SuperFoo<X>", "SuperFoo");
+    doTest("java.lang.StringBuffer", "StringBuffer");
+    doTest("java.lang.StringBuilder", "StringBuilder");
+    doTest("Member<>", "Member");
+    doTest("Nested<>", "Nested");
+    doTest("Neg09.Nested<>", "Nested");
+    doTest("UndeclaredName<>", "UndeclaredName");
+    doTest("L<String>", "L");
+    doTest("P1<P<K>>", "P1");
+    doTest("P<P1T>", "P");
+    doTest("F<X>", "F");
+    doTest("Base<String>", "Base");
+    doTest("Base<Integer>", "Base");
+    doTest("A<V>", "A");
+    doTest("ArrayList<T>", "ArrayList");
+    doTest("I<>", "I");
+    doTest("java.util.Collection<? extends E>", "Collection");
+    doTest("java.util.Map<? extends K,? extends V>", "Map");
+    doTest("java.util.HashMap.Entry", "Entry");
+    doTest("java.util.Iterator<E>", "Iterator");
+    doTest("java.util.ListIterator<E>", "ListIterator");
+    doTest("java.util.List<E>", "List");
+    doTest("@SuppressWarnings", "SuppressWarnings");
+    doTest("java.lang.annotation.Annotation", "Annotation");
+    doTest("@MyAnno", "MyAnno");
+    doTest("java.lang.Exception", "Exception");
+    doTest("@SafeVarargs", "SafeVarargs");
+    doTest("List<T>", "List");
+    doTest("List<String>", "List");
+    doTest("List<?>", "List");
+    doTest("SemKey<String>", "SemKey");
+    doTest("Condition<String>", "Condition");
+    doTest("SemKey<T>", "SemKey");
+    doTest("java.lang.Class<?>", "Class");
+    doTest("A<T>", "A");
+    doTest("java.lang.invoke.MethodType", "MethodType");
+    doTest("java.lang.CharSequence", "CharSequence");
+    doTest("java.lang.IllegalAccessException", "IllegalAccessException");
+    doTest("java.util.Locale", "Locale");
+    doTest("java.util.List<java.lang.Class<?>>", "List");
+    doTest("java.lang.Void", "Void");
+    doTest("java.lang.invoke.MethodHandles.Lookup", "Lookup");
+    doTest("java.lang.invoke.MethodHandle", "MethodHandle");
+    doTest("java.lang.invoke.MethodHandle.PolymorphicSignature", "PolymorphicSignature");
+    doTest("Map<String, String>", "Map");
+    doTest("List<N>", "List");
+    doTest("Wrapper<E, T>", "Wrapper");
+    doTest("X<T>", "X");
+    doTest("Node<String>.Details", "Details");
+    doTest("Map<K, V>", "Map");
+    doTest("Map.Entry<K, V>", "Entry");
+    doTest("Matcher<Collection<? extends E>>", "Matcher");
+    doTest("A<String>", "A");
+    doTest("NonDefaultConstructorContainer.Inner", "Inner");
+    doTest("OtherClass.InnerClass", "InnerClass");
+    doTest("Foo<Number>", "Foo");
+    doTest("Foo<Integer>", "Foo");
+    doTest("Test<String>", "Test");
+    doTest("DiamondTest<String>", "DiamondTest");
+    doTest("ParallelPipeline<T, V>", "ParallelPipeline");
+    doTest("ArrayList<E>", "ArrayList");
+    doTest("Generic<String>", "Generic");
+    doTest("Generic<Object>", "Generic");
+    doTest("java.io.Serializable", "Serializable");
+    doTest("java.lang.Comparable<java.lang.String>", "Comparable");
+    doTest("@Target", "Target");
+    doTest("@TA", "TA");
+    doTest("java.lang.Enum", "Enum");
+    doTest("java.io.OutputStream", "OutputStream");
+    doTest("java.io.OutputStreamWriter", "OutputStreamWriter");
+    doTest("java.io.File", "File");
+    doTest("Foo.IBar", "IBar");
+    doTest("Iterable<Path>", "Iterable");
+    doTest("B<Integer>", "B");
+    doTest("B<Long>", "B");
+    doTest("java.lang.AbstractStringBuilder", "AbstractStringBuilder");
+    doTest("@NotNull", "NotNull");
+    doTest("@Nullable", "Nullable");
+    doTest("java.lang.Runnable", "Runnable");
+    doTest("java.io.FileDescriptor", "FileDescriptor");
+    doTest("java.io.FileNotFoundException", "FileNotFoundException");
+    doTest("java.sql.SQLException", "SQLException");
+    doTest("java.awt.Point", "Point");
+    doTest("List<A.B>", "List");
+    doTest("test.A", "A");
+    doTest("test.Client", "Client");
+    doTest("Pair<String, Pair<Integer, Boolean>>", "Pair");
+    doTest("util.Pair", "Pair");
+    doTest("java.util.Calendar", "Calendar");
+    doTest("java.util.ArrayList", "ArrayList");
+    doTest("java.util.Arrays", "Arrays");
+    doTest("java.util.List", "List");
+    doTest("java.lang.Boolean", "Boolean");
+    doTest("java.lang.ClassLoader", "ClassLoader");
+    doTest("Demo.Pojo2", "Pojo2");
+    doTest("A<E>", "A");
+    doTest("java.lang.reflect.Type", "Type");
+    doTest("java.security.ProtectionDomain", "ProtectionDomain");
+    doTest("java.lang.reflect.Field", "Field");
+    doTest("java.lang.reflect.Method", "Method");
+    doTest("java.lang.reflect.Constructor", "Constructor");
+    doTest("sun.reflect.annotation.AnnotationType", "AnnotationType");
+    doTest("java.lang.reflect.TypeVariable<java.lang.Class<T>>", "TypeVariable");
+    doTest("java.lang.reflect.TypeVariable<?>", "TypeVariable");
+    doTest("java.lang.Class<T>", "Class");
+    doTest("Parent<Integer>", "Parent");
+    doTest("@org.jetbrains.annotations.NotNull", "NotNull");
+    doTest("@org.jetbrains.annotations.Nullable", "Nullable");
+    doTest("org.jetbrains.annotations.NotNull", "NotNull");
+    doTest("org.jetbrains.annotations.Nullable", "Nullable");
+    doTest("IX<Throwable>", "IX");
+    doTest("@org.testng.annotations.BeforeMethod", "BeforeMethod");
+    doTest("Function<String, ?>", "Function");
+    doTest("Function<String>", "Function");
+    doTest("A<Throwable>", "A");
+    doTest("Generic<?>", "Generic");
+    doTest("A1<T>", "A1");
+    doTest("B<T>", "B");
+    doTest("pack.AAClass", "AAClass");
+    doTest("pack.WithInnerAClass", "WithInnerAClass");
+    doTest("java.lang.CloneNotSupportedException", "CloneNotSupportedException");
+    doTest("Foo<ZZZ", "Foo");
+    doTest("@MyObj", "MyObj");
+    doTest("@MyObjectType", "MyObjectType");
+    doTest("@Retention", "Retention");
+    doTest("java.io.FileInputStream", "FileInputStream");
+    doTest("java.lang.Class<? extends java.lang.Object>", "Class");
+    doTest("java.io.ObjectStreamField", "ObjectStreamField");
+    doTest("java.util.Comparator<java.lang.String>", "Comparator");
+    doTest("java.io.FilenameFilter", "FilenameFilter");
+    doTest("java.lang.Class", "Class");
+    doTest("foo.Foo", "Foo");
+    doTest("java.util.List<? super T>", "List");
+    doTest("java.awt.Component", "Component");
+    doTest("java.util.Collection<?>", "Collection");
+    doTest("java.awt.Rectangle", "Rectangle");
+    doTest("javax.swing.JTable", "JTable");
+    doTest("javax.swing.JScrollPane", "JScrollPane");
+    doTest("java.awt.Container", "Container");
+    doTest("java.net.FileNameMap", "FileNameMap");
+    doTest("java.awt.Frame", "Frame");
+    doTest("java.util.List<?>", "List");
+    doTest("java.awt.event.MouseEvent", "MouseEvent");
+    doTest("javax.swing.Action", "Action");
+    doTest("javax.swing.KeyStroke", "KeyStroke");
+    doTest("java.awt.event.KeyEvent", "KeyEvent");
+    doTest("java.io.DataInput", "DataInput");
+    doTest("java.net.ContentHandlerFactory", "ContentHandlerFactory");
+    doTest("java.net.DatagramSocketImplFactory", "DatagramSocketImplFactory");
+    doTest("java.net.SocketImplFactory", "SocketImplFactory");
+    doTest("java.net.URLStreamHandlerFactory", "URLStreamHandlerFactory");
+    doTest("java.util.Collection<? extends T>", "Collection");
+    doTest("java.util.Collection<T>", "Collection");
+    doTest("java.util.List<? extends T>", "List");
+    doTest("java.util.List<T>", "List");
+    doTest("java.util.Map<K,V>", "Map");
+    doTest("java.util.Set<? extends T>", "Set");
+    doTest("java.util.Set<T>", "Set");
+    doTest("java.util.SortedMap<K,? extends V>", "SortedMap");
+    doTest("java.util.SortedMap<K,V>", "SortedMap");
+    doTest("java.util.SortedSet<T>", "SortedSet");
+    doTest("java.lang.Float", "Float");
+    doTest("java.lang.Double", "Double");
+    doTest("java.lang.Short", "Short");
+    doTest("java.lang.annotation.ElementType", "ElementType");
+    doTest("java.lang.Byte", "Byte");
+    doTest("java.util.concurrent.TimeUnit", "TimeUnit");
+    doTest("java.lang.annotation.RetentionPolicy", "RetentionPolicy");
+    doTest("java.lang.Character", "Character");
+    doTest("java.sql.Time", "Time");
+    doTest("java.sql.Date", "Date");
+    doTest("java.sql.Timestamp", "Timestamp");
+    doTest("java.awt.Window", "Window");
+    doTest("Some<caret>", "Some");
+    doTest("foo.bar.AxBxCxDxEx", "AxBxCxDxEx");
+    doTest("net.n3.nanoxml.IXMLReader", "IXMLReader");
+    doTest("net.n3.nanoxml.IXMLBuilder", "IXMLBuilder");
+    doTest("net.n3.nanoxml.IXMLValidator", "IXMLValidator");
+    doTest("net.n3.nanoxml.IXMLEntityResolver", "IXMLEntityResolver");
+    doTest("java.util.Vector", "Vector");
+    doTest("foo.MyClass", "MyClass");
+    doTest("foo.ServiceManager", "ServiceManager");
+    doTest("Bar<String>", "Bar");
+    doTest("pkg.Bar", "Bar");
+    doTest("java.util.Random", "Random");
+    doTest("java.util.Set", "Set");
+    doTest("java.util.Map", "Map");
+    doTest("java.util.Comparator", "Comparator");
+    doTest("java.util.Collection<E>", "Collection");
+    doTest("java.util.Set<E>", "Set");
+    doTest("java.util.SortedSet<E>", "SortedSet");
+    doTest("java.util.Comparator<T>", "Comparator");
+    doTest("java.util.Enumeration<T>", "Enumeration");
+    doTest("pkg.Foo", "Foo");
+    doTest("foo.Bar", "Bar");
+    doTest("sun.nio.ch.Interruptible", "Interruptible");
+    doTest("java.lang.ThreadGroup", "ThreadGroup");
+    doTest("java.lang.Thread", "Thread");
+    doTest("java.lang.Iterable", "Iterable");
+    doTest("java.lang.Package", "Package");
+    doTest("java.lang.reflect.Constructor<?>", "Constructor");
+    doTest("java.lang.reflect.Constructor<T>", "Constructor");
+    doTest("java.lang.Class<U>", "Class");
+    doTest("java.lang.Class<A>", "Class");
+    doTest("java.lang.Class<? extends java.lang.annotation.Annotation>", "Class");
+    doTest("foo.Util", "Util");
+    doTest("java.lang.SecurityManager", "SecurityManager");
+    doTest("java.util.Properties", "Properties");
+    doTest("java.util.Map<java.lang.String,java.lang.String>", "Map");
+    doTest("java.lang.Class<W>", "Class");
+    doTest("java.lang.Class<V>", "Class");
+    doTest("@Foo", "Foo");
+    doTest("@Anno", "Anno");
+    doTest("java.awt.Font", "Font");
+    doTest("java.awt.Graphics", "Graphics");
+    doTest("java.awt.Color", "Color");
+    doTest("java.awt.Dimension", "Dimension");
+    doTest("java.awt.Event", "Event");
+    doTest("java.awt.PopupMenu", "PopupMenu");
+    doTest("java.awt.MenuComponent", "MenuComponent");
+    doTest("java.beans.PropertyChangeListener", "PropertyChangeListener");
+    doTest("java.awt.ComponentOrientation", "ComponentOrientation");
+    doTest("java.awt.LayoutManager", "LayoutManager");
+    doTest("javax.swing.JPopupMenu", "JPopupMenu");
+    doTest("javax.swing.border.Border", "Border");
+    doTest("java.awt.Insets", "Insets");
+    doTest("javax.swing.InputVerifier", "InputVerifier");
+    doTest("java.awt.event.ActionListener", "ActionListener");
+    doTest("javax.swing.ComponentInputMap", "ComponentInputMap");
+    doTest("javax.swing.ActionMap", "ActionMap");
+    doTest("javax.swing.TransferHandler", "TransferHandler");
+    doTest("javax.swing.event.AncestorListener", "AncestorListener");
+    doTest("javax.swing.JComponent", "JComponent");
+    doTest("java.awt.event.ContainerListener", "ContainerListener");
+    doTest("java.awt.AWTEvent", "AWTEvent");
+    doTest("java.awt.event.ContainerEvent", "ContainerEvent");
+    doTest("java.awt.FocusTraversalPolicy", "FocusTraversalPolicy");
+    doTest("java.awt.dnd.DropTarget", "DropTarget");
+    doTest("java.awt.PointerInfo", "PointerInfo");
+    doTest("java.awt.Cursor", "Cursor");
+    doTest("java.awt.Image", "Image");
+    doTest("java.awt.image.ImageProducer", "ImageProducer");
+    doTest("java.awt.event.MouseWheelEvent", "MouseWheelEvent");
+    doTest("java.awt.event.ComponentListener", "ComponentListener");
+    doTest("java.awt.event.FocusListener", "FocusListener");
+    doTest("java.awt.event.HierarchyListener", "HierarchyListener");
+    doTest("java.awt.event.HierarchyBoundsListener", "HierarchyBoundsListener");
+    doTest("java.awt.event.KeyListener", "KeyListener");
+    doTest("java.awt.event.MouseListener", "MouseListener");
+    doTest("java.awt.event.MouseMotionListener", "MouseMotionListener");
+    doTest("java.awt.event.MouseWheelListener", "MouseWheelListener");
+    doTest("java.awt.event.InputMethodListener", "InputMethodListener");
+    doTest("java.awt.event.ComponentEvent", "ComponentEvent");
+    doTest("java.awt.event.FocusEvent", "FocusEvent");
+    doTest("java.awt.event.InputMethodEvent", "InputMethodEvent");
+    doTest("java.awt.event.HierarchyEvent", "HierarchyEvent");
+    doTest("java.util.EventListener", "EventListener");
+    doTest("javax.accessibility.AccessibleContext", "AccessibleContext");
+    doTest("java.awt.peer.ContainerPeer", "ContainerPeer");
+    doTest("javax.swing.InputMap", "InputMap");
+    doTest("javax.swing.JToolTip", "JToolTip");
+    doTest("javax.swing.JRootPane", "JRootPane");
+    doTest("java.awt.peer.ComponentPeer", "ComponentPeer");
+    doTest("java.awt.GraphicsConfiguration", "GraphicsConfiguration");
+    doTest("java.awt.Toolkit", "Toolkit");
+    doTest("java.awt.image.ColorModel", "ColorModel");
+    doTest("java.awt.FontMetrics", "FontMetrics");
+    doTest("java.awt.image.VolatileImage", "VolatileImage");
+    doTest("java.awt.ImageCapabilities", "ImageCapabilities");
+    doTest("java.awt.image.ImageObserver", "ImageObserver");
+    doTest("java.awt.im.InputMethodRequests", "InputMethodRequests");
+    doTest("java.awt.im.InputContext", "InputContext");
+    doTest("javax.swing.JPanel", "JPanel");
+    doTest("@T", "T");
+    doTest("java.util.Set<K>", "Set");
+    doTest("java.util.Collection<V>", "Collection");
+    doTest("java.util.Set<java.util.Map.Entry<K,V>>", "Set");
+    doTest("java.util.Map.Entry<K,V>", "Entry");
+    doTest("java.util.TimeZone", "TimeZone");
+    doTest("java.util.Date", "Date");
+    doTest("AbstractSet<T>", "AbstractSet");
+    doTest("@TestFor", "TestFor");
+    doTest("@MyAnnotation", "MyAnnotation");
+    doTest("@My", "My");
+    doTest("@Test", "Test");
+    doTest("List<V>", "List");
+    doTest("Function<Object, ArrayIndexOutOfBoundsException>", "Function");
+    doTest("@in", "in");
+    doTest("YourMapInterface<K, V>", "YourMapInterface");
+    doTest("@ab", "ab");
+    doTest("List<A>", "List");
+    doTest("@MyAn", "MyAn");
+    doTest("@java.la", "la");
+    doTest("java.lang.Class<E>", "Class");
+    doTest("javax.accessibility.AccessibleStateSet", "AccessibleStateSet");
+    doTest("Bar.", "");
+    doTest("@TestAnnotation", "TestAnnotation");
+    doTest("Key<T>", "Key");
+    doTest("foo.Super", "Super");
+    doTest("@NN", "NN");
+    doTest("java.io.InputStreamReader", "InputStreamReader");
+    doTest("foo.StringValue", "StringValue");
+    doTest("@B", "B");
+    doTest("@Example", "Example");
+    doTest("java.util.HashMap", "HashMap");
+    doTest("@MagicConstant", "MagicConstant");
+    doTest("List<Inner>", "List");
+    doTest("List<bar.Foo.Inner>", "List");
+    doTest("bar.Foo", "Foo");
+    doTest("bar.Assert", "Assert");
+    doTest("java.util.Collections", "Collections");
+    doTest("Foo<String>", "Foo");
+    doTest("Bar<Goo>", "Bar");
+    doTest("java.util.Collection", "Collection");
+    doTest("Collection<Foo>", "Collection");
+    doTest("java.net.URL", "URL");
+    doTest("java.util.Enumeration", "Enumeration");
+    doTest("java.lang.ref.SoftReference", "SoftReference");
+    doTest("sun.reflect.generics.repository.ClassRepository", "ClassRepository");
+    doTest("sun.reflect.ReflectionFactory", "ReflectionFactory");
+    doTest("java.lang.Class.EnclosingMethodInfo", "EnclosingMethodInfo");
+    doTest("sun.reflect.generics.factory.GenericsFactory", "GenericsFactory");
+    doTest("sun.reflect.ConstantPool", "ConstantPool");
+    doTest("javax.swing.event.EventListenerList", "EventListenerList");
+    doTest("javax.swing.ArrayTable", "ArrayTable");
+    doTest("javax.swing.AncestorNotifier", "AncestorNotifier");
+    doTest("java.awt.LightweightDispatcher", "LightweightDispatcher");
+    doTest("sun.awt.DebugHelper", "DebugHelper");
+    doTest("javax.accessibility.Accessible", "Accessible");
+    doTest("java.util.logging.Logger", "Logger");
+    doTest("sun.awt.AppContext", "AppContext");
+    doTest("java.awt.image.BufferStrategy", "BufferStrategy");
+    doTest("java.beans.PropertyChangeSupport", "PropertyChangeSupport");
+    doTest("java.awt.Component.NativeInLightFixer", "NativeInLightFixer");
+    doTest("java.util.concurrent.ConcurrentHashMap<java.lang.String,java.util.Locale>", "ConcurrentHashMap");
+    doTest("sun.util.resources.OpenListResourceBundle", "OpenListResourceBundle");
+    doTest("java.text.MessageFormat", "MessageFormat");
+    doTest("java.security.Provider", "Provider");
+    doTest("Super<String>", "Super");
+    doTest("Super<Integer>", "Super");
+    doTest("Super<T>", "Super");
+    doTest("SubGeneric<T>", "SubGeneric");
+    doTest("MyDD<String>", "MyDD");
+    doTest("java.lang.Class<java.lang.Boolean>", "Class");
+    doTest("MyProcessor<T>", "MyProcessor");
+    doTest("Pair<A,B>", "Pair");
+    doTest("foo.Foo<T>", "Foo");
+    doTest("java.net.URI", "URI");
+    doTest("FList<T>", "FList");
+    doTest("java.util.ArrayList<T>", "ArrayList");
+    doTest("XXX<X>", "XXX");
+    doTest("XXX<Z>", "XXX");
+    doTest("XXX<Z, Z1>", "XXX");
+    doTest("XXX<ZZZ<Z>>", "XXX");
+    doTest("Set<T>", "Set");
+    doTest("Outer.Boo", "Boo");
+    doTest("Params<", "Params");
+    doTest("Key<Impl>", "Key");
+    doTest("ExtensionPointName<T>", "ExtensionPointName");
+    doTest("X<String>", "X");
+    doTest("A<StringBuffer>", "A");
+    doTest("Function<String, String>", "Function");
+    doTest("java.io.FileFilter", "FileFilter");
+    doTest("@Join", "Join");
+    doTest("@Table", "Table");
+    doTest("Computable<Boolean>", "Computable");
+    doTest("Comparable<Foo>", "Comparable");
+    doTest("Goo<String>", "Goo");
+    doTest("Comparator<String>", "Comparator");
+    doTest("@A", "A");
+    doTest("java.awt.geom.Point2D.Double", "Double");
+    doTest("java.awt.geom.Point2D", "Point2D");
+    doTest("bar.Bar", "Bar");
+    doTest("A<T[]>", "A");
+    doTest("IA<String>", "IA");
+    doTest("B<K>", "B");
+    doTest("ArgumentA<Object>", "ArgumentA");
+    doTest("ClassB<E>", "ClassB");
+    doTest("ClassA<E>", "ClassA");
+    doTest("BaseMatcher<String>", "BaseMatcher");
+    doTest("x.A", "A");
+    doTest("x.sub.B", "B");
+    doTest("effectiveAccess.pp<", "pp");
+    doTest("effectiveAccess.pp", "pp");
+    doTest("BaseImpl.Inner", "Inner");
+    doTest("x.Base", "Base");
+    doTest("@java.lang.Deprecated", "Deprecated");
+    doTest("I<II>", "I");
+    doTest("C<Q>", "C");
+    doTest("AC<CC>", "AC");
+    doTest("@Deprecated Object", "Object");
+    doTest("@Ann", "Ann");
+    doTest("@In", "In");
+    doTest("@Inner2", "Inner2");
+    doTest("@java.lang", "lang");
+    doTest("@Expose", "Expose");
+    doTest("@Expose1", "Expose1");
+    doTest("DummyList<? extends String>", "DummyList");
+    doTest("C<C<U>>", "C");
+    doTest("C1<C1<U>>", "C1");
+    doTest("CC<T>", "CC");
+    doTest("Gen<GT>", "Gen");
+    doTest("A1<String>", "A1");
+    doTest("I1<Integer>", "I1");
+    doTest("II1<Integer>", "II1");
+    doTest("II2<Integer>", "II2");
+    doTest("II2<String>", "II2");
+    doTest("II1<Number>", "II1");
+    doTest("II2<Number>", "II2");
+    doTest("AAA<T>", "AAA");
+    doTest("III<T>", "III");
+    doTest("Cmp<Singleton<T1>>", "Cmp");
+    doTest("e<String>", "e");
+    doTest("ValueChangeListener<Number>", "ValueChangeListener");
+    doTest("First<S>", "First");
+    doTest("Second<Integer>", "Second");
+    doTest("SuperA<T, E>", "SuperA");
+    doTest("SuperB<T, E>", "SuperB");
+    doTest("Super<Collection>", "Super");
+    doTest("TypeDispatcher<T,V>", "TypeDispatcher");
+    doTest("DefaultDispatcher<Node, String>", "DefaultDispatcher");
+    doTest("SmartList<Bug2>", "SmartList");
+    doTest("java.util.List<Bug2>", "List");
+    doTest("java.util.AbstractList<E>", "AbstractList");
+    doTest("TableContextAction<Object>", "TableContextAction");
+    doTest("ActionContext<TableContextAction<TCP>>", "ActionContext");
+    doTest("ContextAction<TableContext<RO>>", "ContextAction");
+    doTest("Listener<String>", "Listener");
+    doTest("I<I>", "I");
+    doTest("I<T>", "I");
+    doTest("I<D>", "I");
+    doTest("DT<T>", "DT");
+    doTest("b<d, c>", "b");
+    doTest("c<d, c<c,c>>", "c");
+    doTest("d<b<c<c,c>,d>>", "d");
+    doTest("c<K, c<V,V>>", "c");
+    doTest("d<b<V,K>>", "d");
+    doTest("Z<Integer>", "Z");
+    doTest("BaseC<String>", "BaseC");
+    doTest("Int<T>", "Int");
+    doTest("A<A>", "A");
+    doTest("Outer<String>", "Outer");
+    doTest("Outer<String>.Inner", "Inner");
+    doTest("AbstractClass<AI>", "AbstractClass");
+    doTest("AbstractClass<BI>", "AbstractClass");
+    doTest("PrivilegedExceptionAction<FileNotFoundException>", "PrivilegedExceptionAction");
+    doTest("Printer<T>", "Printer");
+    doTest("I1<C1,C2>", "I1");
+    doTest("I2<C1,C2>", "I2");
+    doTest("List<Decl>", "List");
+    doTest("Reference<T>", "Reference");
+    doTest("Comparable<? super ccc>", "Comparable");
+    doTest("ArrayList<G1>", "ArrayList");
+    doTest("WeakReference<T>", "WeakReference");
+    doTest("Y<Y>", "Y");
+    doTest("ArrayList<String>", "ArrayList");
+    doTest("Comparable<C>", "Comparable");
+    doTest("Comparable<String>", "Comparable");
+    doTest("ZZZ<K>", "ZZZ");
+    doTest("Callable<T>", "Callable");
+    doTest("GenericTest99<E,Double>", "GenericTest99");
+    doTest("Use99<GenericTest99D<?>,Double>", "Use99");
+    doTest("A67675<T[]>", "A67675");
+    doTest("java.util.Comparator<? super T>", "Comparator");
+    doTest("I2<", "I2");
+    doTest("java.util.Map<K, V>", "Map");
+    doTest("AA<BB>", "AA");
+    doTest("GrandParent<T>", "GrandParent");
+    doTest("Base<T[]>", "Base");
+    doTest("Base<T>", "Base");
+    doTest("AbstractParent<E>", "AbstractParent");
+    doTest("Interface<E>", "Interface");
+    doTest("SuperAbstract<Owner, String>", "SuperAbstract");
+    doTest("HalfGenericSuper<Owner>", "HalfGenericSuper");
+    doTest("List<E>", "List");
+    doTest("Comparable<A<T>>", "Comparable");
+    doTest("A<", "A");
+    doTest("Runnable<", "Runnable");
+    doTest("HashMap<K, V>", "HashMap");
+    doTest("Comparable<Object>", "Comparable");
+    doTest("A<K>", "A");
+    doTest("Base <String>", "Base");
+    doTest("Outer<Other>", "Outer");
+    doTest("Lst<?, ?>", "Lst");
+    doTest("Collection<A>", "Collection");
+    doTest("Matcher<? super T>", "Matcher");
+    doTest("ThingUser<?>", "ThingUser");
+    doTest("YO<String>", "YO");
+    doTest("YO<Integer>", "YO");
+    doTest("ArrayList<Integer>", "ArrayList");
+    doTest("Comparable<Date>", "Comparable");
+    doTest("List<Class<? extends Serializable>>", "List");
+    doTest("java.lang.Cloneable", "Cloneable");
+    doTest("Test1<ArrayList>", "Test1");
+    doTest("Comparator<Object>", "Comparator");
+    doTest("TestIF3<T>", "TestIF3");
+    doTest("TestBase<Enum1>", "TestBase");
+    doTest("Comparable<SortTest<R>>", "Comparable");
+    doTest("TypeSafeMap<CoreMap>", "TypeSafeMap");
+    doTest("TypeSafeMap.Key<CoreMap, V>", "Key");
+    doTest("Map<K,V>", "Map");
+    doTest("Version<V, R>", "Version");
+    doTest("Ref<V, R>", "Ref");
+    doTest("VersionEntity<G, GR>", "VersionEntity");
+    doTest("RefEntity<G, GR>", "RefEntity");
+    doTest("Node<?, ?>", "Node");
+    doTest("IQ<", "IQ");
+    doTest("P<TB>", "P");
+    doTest("DomInvocationHandler<FixedChildDescriptionImpl>", "DomInvocationHandler");
+    doTest("RunConfigurationExtension<Bo>", "RunConfigurationExtension");
+    doTest("Comparator<I>", "Comparator");
+    doTest("JSResolveUtil.Resolver<M>", "Resolver");
+    doTest("JSResolveUtil.F", "F");
+    doTest("Model<Inner>", "Model");
+    doTest("Comparator<A.B>", "Comparator");
+    doTest("IConverter<N>", "IConverter");
+    doTest("AbstractNumberConverter<Double>", "AbstractNumberConverter");
+    doTest("IConverter<C>", "IConverter");
+    doTest("Class<? extends Iterator>", "Class");
+    doTest("List<? extends AbstractTreeNode>", "List");
+    doTest("Iterator<T>", "Iterator");
+    doTest("Class<E>", "Class");
+    doTest("Comparator<byte[]>", "Comparator");
+    doTest("C<T,T>", "C");
+    doTest("A2<T>", "A2");
+    doTest("A3<T>", "A3");
+    doTest("IB<", "IB");
+    doTest("A<S>", "A");
+    doTest("B<String>", "B");
+    doTest("List<List<T>>", "List");
+    doTest("I<A[]>", "I");
+    doTest("I<B[]>", "I");
+    doTest("A<S,T>", "A");
+    doTest("F<A, P1<B>>", "F");
+    doTest("Iterable<T>", "Iterable");
+    doTest("A<Integer>", "A");
+    doTest("Pair<A, B>", "Pair");
+    doTest("Field<Object>", "Field");
+    doTest("MyInterface<Object>", "MyInterface");
+    doTest("Class<I>", "Class");
+    doTest("Outer.Inner", "Inner");
+    doTest("Comparator<K>", "Comparator");
+    doTest("Comparable<SelfComparable>", "Comparable");
+    doTest("Collection<T>", "Collection");
+    doTest("Collection<E>", "Collection");
+    doTest("Iterator<E>", "Iterator");
+    doTest("UnmodifiableCollection<E>", "UnmodifiableCollection");
+    doTest("Set<E>", "Set");
+    doTest("SortedSet<T>", "SortedSet");
+    doTest("UnmodifiableSet<E>", "UnmodifiableSet");
+    doTest("SortedSet<E>", "SortedSet");
+    doTest("ListIterator<E>", "ListIterator");
+    doTest("UnmodifiableList<E>", "UnmodifiableList");
+    doTest("UnmodifiableSet<Map.Entry<K,V>>", "UnmodifiableSet");
+    doTest("Iterator<Map.Entry<K,V>>", "Iterator");
+    doTest("Map.Entry<K,V>", "Entry");
+    doTest("SortedMap<K,V>", "SortedMap");
+    doTest("UnmodifiableMap<K,V>", "UnmodifiableMap");
+    doTest("SynchronizedCollection<E>", "SynchronizedCollection");
+    doTest("SynchronizedSet<E>", "SynchronizedSet");
+    doTest("SynchronizedList<E>", "SynchronizedList");
+    doTest("SynchronizedMap<K,V>", "SynchronizedMap");
+    doTest("CheckedCollection<E>", "CheckedCollection");
+    doTest("CheckedSet<E>", "CheckedSet");
+    doTest("CheckedList<E>", "CheckedList");
+    doTest("Set<Map.Entry<K,V>>", "Set");
+    doTest("CheckedMap<K,V>", "CheckedMap");
+    doTest("AbstractSet<Object>", "AbstractSet");
+    doTest("Iterator<Object>", "Iterator");
+    doTest("AbstractList<Object>", "AbstractList");
+    doTest("AbstractMap<Object,Object>", "AbstractMap");
+    doTest("AbstractSet<E>", "AbstractSet");
+    doTest("AbstractList<E>", "AbstractList");
+    doTest("AbstractMap<K,V>", "AbstractMap");
+    doTest("Comparator<T>", "Comparator");
+    doTest("Comparator<Comparable<Object>>", "Comparator");
+    doTest("Enumeration<T>", "Enumeration");
+    doTest("java.util.SortedMap", "SortedMap");
+    doTest("java.util.AbstractList", "AbstractList");
+    doTest("java.util.TreeMap", "TreeMap");
+    doTest("java.util.concurrent.atomic.AtomicBoolean", "AtomicBoolean");
+    doTest("x.n.X1", "X1");
+    doTest("x.n.X2", "X2");
+    doTest("x.n.X3", "X3");
+    doTest("java.util.X", "X");
+    doTest("java.io.Reader", "Reader");
+    doTest("java.security.cert.Certificate", "Certificate");
+    doTest("i<", "i");
+    doTest("ii<", "ii");
+    doTest("i2<", "i2");
+    doTest("A57.X", "X");
+    doTest("A.B", "B");
+    doTest("A42.B", "B");
+    doTest("B57.X", "X");
+    doTest("c4<", "c4");
+    doTest("i7<", "i7");
+    doTest("c8<", "c8");
+    doTest("i5<", "i5");
+    doTest("ConflictWithObject<", "ConflictWithObject");
+    doTest("MethodsFromObject<", "MethodsFromObject");
+    doTest("java.awt.event.ActionEvent", "ActionEvent");
+    doTest("a<", "a");
+    doTest("A1<", "A1");
+    doTest("Foo<", "Foo");
+    doTest("c2<", "c2");
+    doTest("c1<", "c1");
+    doTest("java.awt.BufferCapabilities", "BufferCapabilities");
+    doTest("java.io.ObjectOutput", "ObjectOutput");
+    doTest("java.io.ObjectInput", "ObjectInput");
+    doTest("java.lang.ClassNotFoundException", "ClassNotFoundException");
+    doTest("IFoo.UNKNOWN", "UNKNOWN");
+    doTest("Integer.MAX_VALUE", "MAX_VALUE");
+    doTest("Inner1<", "Inner1");
+    doTest("D.B", "B");
+    doTest("D.", "");
+    doTest("D.B1", "B1");
+    doTest("A.B1", "B1");
+    doTest("C1.B1", "B1");
+    doTest("@java.lang.SuppressWarnings", "SuppressWarnings");
+    doTest("BaseStream<T>", "BaseStream");
+    doTest("StreamOp<E_IN, Node<E_OUT>>", "StreamOp");
+    doTest("IntermediateOp<E_IN, E_OUT>", "IntermediateOp");
+    doTest("StreamOp<E_IN, R>", "StreamOp");
+    doTest("StatefulOp<T, T>", "StatefulOp");
+    doTest("Foo1<Integer, Integer>", "Foo1");
+    doTest("List<B>", "List");
+    doTest("Optional<U>", "Optional");
+    doTest("BiFunction<T, T, T>", "BiFunction");
+    doTest("Collector<T, M1>", "Collector");
+    doTest("BinaryOperator<M2>", "BinaryOperator");
+    doTest("Collector<T, R>", "Collector");
+    doTest("C<T, M1>", "C");
+    doTest("BiOp<M2>", "BiOp");
+    doTest("C<T, R>", "C");
+    doTest("BiFun<T, T, T>", "BiFun");
+    doTest("Map<A, B>", "Map");
+    doTest("Map<K1, M1>", "Map");
+    doTest("FindOp<MT, Optional<MT>>", "FindOp");
+    doTest("TerminalSink<FindSinkT, FindSinkO>", "TerminalSink");
+    doTest("FindSink<OfRefT, Optional<OfRefT>>", "FindSink");
+    doTest("FindOp1<MT, Optional<MT>>", "FindOp1");
+    doTest("FindOp2<MT, Optional<MT>>", "FindOp2");
+    doTest("Optional<T>", "Optional");
+    doTest("Consumer<T>", "Consumer");
+    doTest("@FunctionalInterface", "FunctionalInterface");
+    doTest("Sink<Integer>", "Sink");
+    doTest("Sink<T>", "Sink");
+    doTest("FirstParent<", "FirstParent");
+    doTest("Block<T>", "Block");
+    doTest("TerminalSink<T, Void>", "TerminalSink");
+    doTest("VoidTerminalSink<Integer>", "VoidTerminalSink");
+    doTest("Sink.OfInt", "OfInt");
+    doTest("VoidTerminalSink.OfInt<", "OfInt");
+    doTest("ForEachOp<T>", "ForEachOp");
+    doTest("VoidTerminalSink.OfInt", "OfInt");
+    doTest("Iso<R, T>", "Iso");
+    doTest("I<X>", "I");
+    doTest("I1<T>", "I1");
+    doTest("I2<T>", "I2");
+    doTest("Y<Object>", "Y");
+    doTest("BinaryOperator<Integer>", "BinaryOperator");
+    doTest("Combiner<T,T,T>", "Combiner");
+    doTest("IntermediateOp<L, M>", "IntermediateOp");
+    doTest("IntermediateOp1<T, U>", "IntermediateOp1");
+    doTest("I<A,B>", "I");
+    doTest("A<L>", "A");
+    doTest("SameArgsI<T>", "SameArgsI");
+    doTest("LambdaTest<U>", "LambdaTest");
+    doTest("Option<T>", "Option");
+    doTest("Function<T, Integer>", "Function");
+    doTest("BaseStream<Integer>", "BaseStream");
+    doTest("Comparator<Map.Entry<K, V>>", "Comparator");
+    doTest("Function<T, T>", "Function");
+    doTest("A<M>", "A");
+    doTest("Foo<X>", "Foo");
+    doTest("Iterable<U>", "Iterable");
+    doTest("ASink<R, Moo>", "ASink");
+    doTest("ASink<AAMoo, AAMoo>", "ASink");
+    doTest("ASink<R, AAAMoo>", "ASink");
+    doTest("Collector<T, C>", "Collector");
+    doTest("Collector<T, List<T>>", "Collector");
+    doTest("Stream<C>", "Stream");
+    doTest("BiFunction<T,T,T>", "BiFunction");
+    doTest("Collector<Integer, R>", "Collector");
+    doTest("C.E2", "E2");
+    doTest("C.E1", "E1");
+    doTest("java.nio.charset.Charset", "Charset");
+    doTest("java.nio.charset.CharsetDecoder", "CharsetDecoder");
+    doTest("I<String>", "I");
+    doTest("InOut<B>", "InOut");
+    doTest("DeeBee<B>", "DeeBee");
+    doTest("b<C.D>", "b");
+    doTest("b<String>", "b");
+    doTest("Foo.Bar", "Bar");
+    doTest("@Attr", "Attr");
+    doTest("javax.swing.table.TableModel", "TableModel");
+    doTest("javax.swing.event.TableModelListener", "TableModelListener");
+    doTest("@BeanAware", "BeanAware");
+    doTest("java.awt.MenuContainer", "MenuContainer");
+    doTest("java.lang.Number", "Number");
+    doTest("Foo<Bug>", "Foo");
+    doTest("Seq<T>", "Seq");
+    doTest("Seq<V>", "Seq");
+    doTest("Comparable<R>", "Comparable");
+    doTest("@org.jetbrains.annotations.NonNls", "NonNls");
+    doTest("org.jetbrains.annotations.NonNls", "NonNls");
+    doTest("@NonNls", "NonNls");
+    doTest("MatchOp<T>", "MatchOp");
+    doTest("BooleanTerminalSink<T>", "BooleanTerminalSink");
+    doTest("Callable<String>", "Callable");
+    doTest("Callable<Integer>", "Callable");
+    doTest("AsyncTask<String, Integer, Long>", "AsyncTask");
+    doTest("AsyncTask<String,Integer,Integer>", "AsyncTask");
+    doTest("List<AppInfo>", "List");
+    doTest("ArrayList<ResolveInfo>", "ArrayList");
+    doTest("CallableEx<String>", "CallableEx");
+    doTest("Callable<TE>", "Callable");
+    doTest("CallableEx<Integer>", "CallableEx");
+    doTest("TestCase<caret>", "TestCase");
+    doTest("@org.ju", "ju");
+    doTest("l.InLib", "InLib");
+    doTest("junit.framework.Assert", "Assert");
+    doTest("junit.framework.TestCase", "TestCase");
+    doTest("junit.framework.Test", "Test");
+    doTest("junit.framework.TestSuite", "TestSuite");
+    doTest("junit.framework.TestResult", "TestResult");
+    doTest("junit.framework.TestListener", "TestListener");
+    doTest("junit.framework.TestFailure", "TestFailure");
+    doTest("junit.framework.ComparisonFailure", "ComparisonFailure");
+    doTest("junit.framework.AssertionFailedError", "AssertionFailedError");
+    doTest("x.InA", "InA");
+    doTest("y.AddDependency", "AddDependency");
+    doTest("y.AddLibrary", "AddLibrary");
+    doTest("x.DoTest", "DoTest");
+    doTest("@org.junit.Test", "Test");
+    doTest("org.junit.Test", "Test");
+    doTest("x.DoTest4", "DoTest4");
+    doTest("Some<K, T>", "Some");
+    doTest("java.util.Collection<? super T>", "Collection");
+    doTest("I.FOO", "FOO");
+    doTest("I.FOO1", "FOO1");
+    doTest("I.FOO2", "FOO2");
+    doTest("I.FOO3", "FOO3");
+    doTest("I.FOO4", "FOO4");
+    doTest("I.FOO5", "FOO5");
+    doTest("@java.lang.SafeVarargs", "SafeVarargs");
+    doTest("M<T>", "M");
+    doTest("M<String>", "M");
+    doTest("@javax.annotation.Generated", "Generated");
+    doTest("II<String>", "II");
+    doTest("AroundTemplateMethod<T>", "AroundTemplateMethod");
+    doTest("SetupTimer<Integer>", "SetupTimer");
+    doTest("bar.Log", "Log");
+    doTest("@Bar.Foo", "Foo");
+    doTest("I<Object>", "I");
+    doTest("Superclass<E, Q>", "Superclass");
+    doTest("@org.testng.annotations.Test", "Test");
+    doTest("@org.junit.Before", "Before");
+    doTest("Ref<T>", "Ref");
+    doTest("M<MX, MY>", "M");
+    doTest("Proc<String>", "Proc");
+    doTest("Proc<Integer>", "Proc");
+    doTest("java.util.Iterator", "Iterator");
+    doTest("p1.Base", "Base");
+    doTest("javax.swing.Icon", "Icon");
+    doTest("java.awt.Dialog", "Dialog");
+    doTest("javax.swing.JLabel", "JLabel");
+    doTest("test.Matcher", "Matcher");
+    doTest("java.util.Collections.CopiesList", "CopiesList");
+    doTest("java.util.Collections.EmptyList", "EmptyList");
+    doTest("java.util.Collections.EmptyMap", "EmptyMap");
+    doTest("java.util.Collections.EmptySet", "EmptySet");
+    doTest("java.util.Collections.ReverseComparator", "ReverseComparator");
+    doTest("java.util.Collections.ReverseComparator2", "ReverseComparator2");
+    doTest("java.util.Collections.SelfComparable", "SelfComparable");
+    doTest("java.util.Collections.SingletonList", "SingletonList");
+    doTest("java.util.Collections.SingletonMap", "SingletonMap");
+    doTest("java.util.Collections.SingletonMap.ImmutableEntry", "ImmutableEntry");
+    doTest("java.util.Collections.SingletonSet", "SingletonSet");
+    doTest("java.util.Collections.SynchronizedCollection", "SynchronizedCollection");
+    doTest("java.util.Collections.SynchronizedList", "SynchronizedList");
+    doTest("java.util.Collections.SynchronizedMap", "SynchronizedMap");
+    doTest("java.util.Collections.SynchronizedRandomAccessList", "SynchronizedRandomAccessList");
+    doTest("java.util.Collections.SynchronizedSet", "SynchronizedSet");
+    doTest("java.util.Collections.SynchronizedSortedMap", "SynchronizedSortedMap");
+    doTest("java.util.Collections.SynchronizedSortedSet", "SynchronizedSortedSet");
+    doTest("java.util.Collections.UnmodifiableCollection", "UnmodifiableCollection");
+    doTest("java.util.Collections.UnmodifiableList", "UnmodifiableList");
+    doTest("java.util.Collections.UnmodifiableMap", "UnmodifiableMap");
+    doTest("java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet", "UnmodifiableEntrySet");
+    doTest("java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet.UnmodifiableEntry", "UnmodifiableEntry");
+    doTest("java.util.Collections.UnmodifiableRandomAccessList", "UnmodifiableRandomAccessList");
+    doTest("java.util.Collections.UnmodifiableSet", "UnmodifiableSet");
+    doTest("java.util.Collections.UnmodifiableSortedMap", "UnmodifiableSortedMap");
+    doTest("java.util.Collections.UnmodifiableSortedSet", "UnmodifiableSortedSet");
+    doTest("java.util.Map.Entry", "Entry");
+    doTest("AnnotatedNonStaticInnerClassConstructor.Inner", "Inner");
+    doTest("pack.Modifiers", "Modifiers");
+    doTest("pkg.Deprecated", "Deprecated");
+    doTest("pkg.package-info", "package-info");
+    doTest("pkg.Nested", "Nested");
+    doTest("pkg.Nested.Inner1", "Inner1");
+    doTest("pkg.Nested.Inner1.Inner2", "Inner2");
+    doTest("pkg.SimpleEnum", "SimpleEnum");
+    doTest("pkg.EnumWithFields", "EnumWithFields");
+    doTest("pkg.NormalClass", "NormalClass");
+    doTest("pkg.NormalClass.Inner", "Inner");
+    doTest("pkg.Annotations", "Annotations");
+    doTest("pkg.Annotations.IndeterminateAnno", "IndeterminateAnno");
+    doTest("pkg.Annotations.A4", "A4");
+    doTest("pkg.Annotations.A3", "A3");
+    doTest("pkg.Annotations.A2", "A2");
+    doTest("pkg.Annotations.A1", "A1");
+    doTest("pkg.ParameterNames", "ParameterNames");
+    doTest("pkg.EmptyEnum", "EmptyEnum");
+    doTest("pkg.$BuckClass", "$BuckClass");
+    doTest("pkg.BuckClass$", "BuckClass$");
+    doTest("pkg.ExtMethods", "ExtMethods");
+    doTest("pkg.MethodReceiver", "MethodReceiver");
+    doTest("pkg.MethodReceiver.A", "A");
+    doTest("com.google.android.maps.OverlayItem", "OverlayItem");
+    doTest("com.google.android.maps.GeoPoint", "GeoPoint");
+    doTest("android.graphics.drawable.Drawable", "Drawable");
+    doTest("com.TestClass", "TestClass");
+    doTest("ppp.BadClass", "BadClass");
+    doTest("@AnnotationType", "AnnotationType");
+    doTest("@annotations.AnnotationType", "AnnotationType");
+    doTest("List<Integer>", "List");
+    doTest("List<List<Integer>>", "List");
+    doTest("pack.MyClass", "MyClass");
+    doTest("p2.A", "A");
+    doTest("p1.A", "A");
+    doTest("Parent.Child", "Child");
+    doTest("net.n3.nanoxml.XMLUtil", "XMLUtil");
+    doTest("net.n3.nanoxml.PIReader", "PIReader");
+    doTest("net.n3.nanoxml.XMLWriter", "XMLWriter");
+    doTest("net.n3.nanoxml.IXMLParser", "IXMLParser");
+    doTest("net.n3.nanoxml.XMLElement", "XMLElement");
+    doTest("net.n3.nanoxml.CDATAReader", "CDATAReader");
+    doTest("net.n3.nanoxml.IXMLElement", "IXMLElement");
+    doTest("net.n3.nanoxml.NonValidator", "NonValidator");
+    doTest("net.n3.nanoxml.StdXMLParser", "StdXMLParser");
+    doTest("net.n3.nanoxml.StdXMLReader", "StdXMLReader");
+    doTest("net.n3.nanoxml.XMLAttribute", "XMLAttribute");
+    doTest("net.n3.nanoxml.StdXMLReader.StackedReader", "StackedReader");
+    doTest("net.n3.nanoxml.XMLException", "XMLException");
+    doTest("net.n3.nanoxml.ContentReader", "ContentReader");
+    doTest("net.n3.nanoxml.StdXMLBuilder", "StdXMLBuilder");
+    doTest("net.n3.nanoxml.ValidatorPlugin", "ValidatorPlugin");
+    doTest("net.n3.nanoxml.XMLParserFactory", "XMLParserFactory");
+    doTest("net.n3.nanoxml.XMLEntityResolver", "XMLEntityResolver");
+    doTest("net.n3.nanoxml.XMLParseException", "XMLParseException");
+    doTest("net.n3.nanoxml.XMLValidationException", "XMLValidationException");
+    doTest("com.google.protobuf.Message", "Message");
+    doTest("com.google.protobuf.RpcUtil", "RpcUtil");
+    doTest("com.google.protobuf.Service", "Service");
+    doTest("com.google.protobuf.Message.Builder", "Builder");
+    doTest("com.google.protobuf.FieldSet", "FieldSet");
+    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite", "FieldDescriptorLite");
+    doTest("com.google.protobuf.Internal", "Internal");
+    doTest("com.google.protobuf.RpcUtil.AlreadyCalledException", "AlreadyCalledException");
+    doTest("com.google.protobuf.Internal.EnumLiteMap", "EnumLiteMap");
+    doTest("com.google.protobuf.RpcCallback<Type>", "RpcCallback");
+    doTest("com.google.protobuf.Internal.EnumLite", "EnumLite");
+    doTest("com.google.protobuf.MessageLite", "MessageLite");
+    doTest("com.google.protobuf.MessageOrBuilder", "MessageOrBuilder");
+    doTest("com.google.protobuf.MessageLite.Builder", "Builder");
+    doTest("com.google.protobuf.RpcCallback<com.google.protobuf.Message>", "RpcCallback");
+    doTest("com.google.protobuf.ByteString", "ByteString");
+    doTest("com.google.protobuf.RpcCallback<ParameterType>", "RpcCallback");
+    doTest("com.google.protobuf.RpcChannel", "RpcChannel");
+    doTest("com.google.protobuf.ByteString.CodedBuilder", "CodedBuilder");
+    doTest("com.google.protobuf.TextFormat", "TextFormat");
+    doTest("com.google.protobuf.WireFormat", "WireFormat");
+    doTest("com.google.protobuf.TextFormat.InvalidEscapeSequenceException", "InvalidEscapeSequenceException");
+    doTest("com.google.protobuf.WireFormat.FieldType", "FieldType");
+    doTest("com.google.protobuf.ByteString.Output", "Output");
+    doTest("com.google.protobuf.TextFormat.ParseException", "ParseException");
+    doTest("com.google.protobuf.TextFormat.Tokenizer", "Tokenizer");
+    doTest("com.google.protobuf.WireFormat.JavaType", "JavaType");
+    doTest("java.io.FilterOutputStream", "FilterOutputStream");
+    doTest("java.lang.Comparable<T>", "Comparable");
+    doTest("com.google.protobuf.FieldSet<T>", "FieldSet");
+    doTest("com.google.protobuf.Descriptors", "Descriptors");
+    doTest("com.google.protobuf.RpcCallback", "RpcCallback");
+    doTest("com.google.protobuf.Descriptors.DescriptorPool", "DescriptorPool");
+    doTest("com.google.protobuf.RpcController", "RpcController");
+    doTest("com.google.protobuf.DynamicMessage", "DynamicMessage");
+    doTest("com.google.protobuf.Descriptors.DescriptorPool.DescriptorIntPair", "DescriptorIntPair");
+    doTest("com.google.protobuf.DynamicMessage.Builder", "Builder");
+    doTest("com.google.protobuf.TextFormat.TextGenerator", "TextGenerator");
+    doTest("com.google.protobuf.Descriptors.DescriptorPool.PackageDescriptor", "PackageDescriptor");
+    doTest("com.google.protobuf.MessageLiteOrBuilder", "MessageLiteOrBuilder");
+    doTest("com.google.protobuf.TextFormat.Printer", "Printer");
+    doTest("com.google.protobuf.LazyStringList", "LazyStringList");
+    doTest("java.util.List<java.lang.String>", "List");
+    doTest("com.google.protobuf.SmallSortedMap", "SmallSortedMap");
+    doTest("com.google.protobuf.SmallSortedMap.EmptySet", "EmptySet");
+    doTest("com.google.protobuf.SmallSortedMap.EntryIterator", "EntryIterator");
+    doTest("com.google.protobuf.SmallSortedMap.EntrySet", "EntrySet");
+    doTest("com.google.protobuf.SmallSortedMap.Entry", "Entry");
+    doTest("java.util.AbstractMap<K,V>", "AbstractMap");
+    doTest("java.lang.Iterable<T>", "Iterable");
+    doTest("java.util.Iterator<java.util.Map.Entry<K,V>>", "Iterator");
+    doTest("java.util.AbstractSet<java.util.Map.Entry<K,V>>", "AbstractSet");
+    doTest("java.lang.Comparable<com.google.protobuf.SmallSortedMap<K,V>.Entry>", "Comparable");
+    doTest("com.google.protobuf.SmallSortedMap<FieldDescriptorType,java.lang.Object>", "SmallSortedMap");
+    doTest("com.google.protobuf.SmallSortedMap<K,V>", "SmallSortedMap");
+    doTest("com.google.protobuf.AbstractMessage", "AbstractMessage");
+    doTest("com.google.protobuf.AbstractMessage.Builder<com.google.protobuf.DynamicMessage.Builder>", "Builder");
+    doTest("com.google.protobuf.Descriptors.DescriptorValidationException", "DescriptorValidationException");
+    doTest("com.google.protobuf.BlockingService", "BlockingService");
+    doTest("com.google.protobuf.AbstractMessage.Builder", "Builder");
+    doTest("com.google.protobuf.Descriptors.GenericDescriptor", "GenericDescriptor");
+    doTest("com.google.protobuf.UnknownFieldSet", "UnknownFieldSet");
+    doTest("com.google.protobuf.UnknownFieldSet.Field", "Field");
+    doTest("com.google.protobuf.Descriptors.MethodDescriptor", "MethodDescriptor");
+    doTest("com.google.protobuf.UnknownFieldSet.Field.Builder", "Builder");
+    doTest("com.google.protobuf.CodedInputStream", "CodedInputStream");
+    doTest("com.google.protobuf.UnknownFieldSet.Builder", "Builder");
+    doTest("com.google.protobuf.Descriptors.ServiceDescriptor", "ServiceDescriptor");
+    doTest("com.google.protobuf.AbstractMessageLite", "AbstractMessageLite");
+    doTest("com.google.protobuf.AbstractMessageLite.Builder<BuilderType>", "Builder");
+    doTest("com.google.protobuf.UninitializedMessageException", "UninitializedMessageException");
+    doTest("com.google.protobuf.GeneratedMessage", "GeneratedMessage");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable", "FieldAccessorTable");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedMessageFieldAccessor", "RepeatedMessageFieldAccessor");
+    doTest("com.google.protobuf.Descriptors.EnumValueDescriptor", "EnumValueDescriptor");
+    doTest("com.google.protobuf.ServiceException", "ServiceException");
+    doTest("com.google.protobuf.Descriptors.EnumDescriptor", "EnumDescriptor");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularMessageFieldAccessor", "SingularMessageFieldAccessor");
+    doTest("com.google.protobuf.CodedOutputStream", "CodedOutputStream");
+    doTest("com.google.protobuf.CodedOutputStream.OutOfSpaceException", "OutOfSpaceException");
+    doTest("com.google.protobuf.Descriptors.FieldDescriptor", "FieldDescriptor");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedEnumFieldAccessor", "RepeatedEnumFieldAccessor");
+    doTest("com.google.protobuf.Descriptors.FieldDescriptor.JavaType", "JavaType");
+    doTest("com.google.protobuf.ExtensionRegistry", "ExtensionRegistry");
+    doTest("com.google.protobuf.ExtensionRegistry.DescriptorIntPair", "DescriptorIntPair");
+    doTest("com.google.protobuf.ExtensionRegistry.ExtensionInfo", "ExtensionInfo");
+    doTest("com.google.protobuf.Descriptors.FieldDescriptor.Type", "Type");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularEnumFieldAccessor", "SingularEnumFieldAccessor");
+    doTest("com.google.protobuf.ExtensionRegistryLite", "ExtensionRegistryLite");
+    doTest("com.google.protobuf.BlockingRpcChannel", "BlockingRpcChannel");
+    doTest("com.google.protobuf.SingleFieldBuilder", "SingleFieldBuilder");
+    doTest("com.google.protobuf.GeneratedMessage.BuilderParent", "BuilderParent");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedFieldAccessor", "RepeatedFieldAccessor");
+    doTest("com.google.protobuf.AbstractMessageLite.Builder", "Builder");
+    doTest("com.google.protobuf.AbstractMessageLite.Builder.LimitedInputStream", "LimitedInputStream");
+    doTest("java.io.FilterInputStream", "FilterInputStream");
+    doTest("com.google.protobuf.LazyStringArrayList", "LazyStringArrayList");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularFieldAccessor", "SingularFieldAccessor");
+    doTest("java.util.AbstractList<java.lang.String>", "AbstractList");
+    doTest("java.util.RandomAccess", "RandomAccess");
+    doTest("com.google.protobuf.ProtocolMessageEnum", "ProtocolMessageEnum");
+    doTest("com.google.protobuf.GeneratedMessageLite", "GeneratedMessageLite");
+    doTest("com.google.protobuf.GeneratedMessageLite.SerializedForm", "SerializedForm");
+    doTest("com.google.protobuf.GeneratedMessageLite.GeneratedExtension", "GeneratedExtension");
+    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.FieldAccessor", "FieldAccessor");
+    doTest("com.google.protobuf.Descriptors.Descriptor", "Descriptor");
+    doTest("com.google.protobuf.GeneratedMessageLite.ExtensionDescriptor", "ExtensionDescriptor");
+    doTest("com.google.protobuf.GeneratedMessage.GeneratedExtension", "GeneratedExtension");
+    doTest("com.google.protobuf.GeneratedMessageLite.Builder", "Builder");
+    doTest("com.google.protobuf.GeneratedMessage.ExtensionDescriptorRetriever", "ExtensionDescriptorRetriever");
+    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite<com.google.protobuf.GeneratedMessageLite.ExtensionDescriptor>", "FieldDescriptorLite");
+    doTest("com.google.protobuf.GeneratedMessageLite.Builder<MessageType,BuilderType>", "Builder");
+    doTest("com.google.protobuf.GeneratedMessageLite.GeneratedExtension<ContainingType,Type>", "GeneratedExtension");
+    doTest("com.google.protobuf.Descriptors.FileDescriptor", "FileDescriptor");
+    doTest("com.google.protobuf.RepeatedFieldBuilder", "RepeatedFieldBuilder");
+    doTest("com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner", "InternalDescriptorAssigner");
+    doTest("com.google.protobuf.RepeatedFieldBuilder.MessageOrBuilderExternalList", "MessageOrBuilderExternalList");
+    doTest("com.google.protobuf.RepeatedFieldBuilder.BuilderExternalList", "BuilderExternalList");
+    doTest("com.google.protobuf.RepeatedFieldBuilder.MessageExternalList", "MessageExternalList");
+    doTest("java.util.AbstractList<IType>", "AbstractList");
+    doTest("java.util.List<IType>", "List");
+    doTest("java.util.AbstractList<BType>", "AbstractList");
+    doTest("java.util.List<BType>", "List");
+    doTest("java.util.AbstractList<MType>", "AbstractList");
+    doTest("java.util.List<MType>", "List");
+    doTest("com.google.protobuf.ExtensionRegistryLite.ObjectIntPair", "ObjectIntPair");
+    doTest("com.google.protobuf.GeneratedMessage.Builder", "Builder");
+    doTest("com.google.protobuf.Internal.EnumLiteMap<com.google.protobuf.Descriptors.EnumValueDescriptor>", "EnumLiteMap");
+    doTest("java.lang.Comparable<com.google.protobuf.Descriptors.FieldDescriptor>", "Comparable");
+    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite<com.google.protobuf.Descriptors.FieldDescriptor>", "FieldDescriptorLite");
+    doTest("com.google.protobuf.GeneratedMessage.Builder.BuilderParentImpl", "BuilderParentImpl");
+    doTest("com.google.protobuf.UnmodifiableLazyStringList", "UnmodifiableLazyStringList");
+    doTest("Map<Integer, Integer>", "Map");
+    doTest("java.lang.Comparable<T.NameRef>", "Comparable");
+    doTest("List<T[]>", "List");
+    doTest("Condition<T>", "Condition");
+    doTest("Class<Foo>", "Class");
+    doTest("Class<Runnable>", "Class");
+    doTest("Foo<BarImpl>", "Foo");
+    doTest("Y<T>", "Y");
+    doTest("GenericClass<String>", "GenericClass");
+    doTest("A.I", "I");
+    doTest("Test<T>", "Test");
+    doTest("Comparable<Integer>", "Comparable");
+    doTest("Iterator<Map.Entry<K, V>>", "Iterator");
+    doTest("Predicate<T>", "Predicate");
+    doTest("Foo.Predicate<T>", "Predicate");
+    doTest("Callable<Object>", "Callable");
+    doTest("C<String>", "C");
+    doTest("p1.S2", "S2");
+    doTest("p2.S1", "S1");
+    doTest("p1.S1", "S1");
+    doTest("p2.S2", "S2");
+    doTest("p2.p1.S1", "S1");
+    doTest("p2.p1.S2", "S2");
+    doTest("@javax.xml.bind.annotation.XmlSchema", "XmlSchema");
+    doTest("A <R>", "A");
+    doTest("Extracted.Inner", "Inner");
+    doTest("java.util.List<String>", "List");
+    doTest("@java.lang.Override", "Override");
+    doTest("a.Test", "Test");
+    doTest("b.TestSubclass", "TestSubclass");
+    doTest("java.util.ListIterator", "ListIterator");
+    doTest("p1.AA", "AA");
+    doTest("p2.C", "C");
+    doTest("java.math.BigDecimal", "BigDecimal");
+    doTest("java.sql.SQLWarning", "SQLWarning");
+    doTest("java.sql.ResultSetMetaData", "ResultSetMetaData");
+    doTest("java.sql.Statement", "Statement");
+    doTest("java.sql.Ref", "Ref");
+    doTest("java.sql.Blob", "Blob");
+    doTest("java.sql.Clob", "Clob");
+    doTest("java.sql.Array", "Array");
+    doTest("java.sql.ResultSet", "ResultSet");
+    doTest("p.Test", "Test");
+    doTest("p1.Usage", "Usage");
+    doTest("Super<R>", "Super");
+    doTest("java.lang.Comparable<java.lang.Long>", "Comparable");
+    doTest("R<String, Object>", "R");
+    doTest("Res.R<java.lang.String,java.lang.Object>", "R");
+    doTest("Res.R<String,java.lang.Object>", "R");
+    doTest("Res.R<String,Object>", "R");
+    doTest("Res.R<String, Object>", "R");
+    doTest("@Before", "Before");
+    doTest("org.junit.Before", "Before");
+    doTest("Test<G, T>", "Test");
+    doTest("p.Param", "Param");
+    doTest("p2.Test", "Test");
+    doTest("pack1.Class2", "Class2");
+    doTest("pack2.Class1", "Class1");
+    doTest("pack1.X", "X");
+    doTest("pack2.X", "X");
+    doTest("pack2.A", "A");
+    doTest("pack1.Class1", "Class1");
+    doTest("packUser.Class2", "Class2");
+    doTest("pack0.Class0", "Class0");
+    doTest("pack2.A.Class1", "Class1");
+    doTest("A.Class1", "Class1");
+    doTest("pack1.Usage", "Usage");
+    doTest("pack1.StaticInner", "StaticInner");
+    doTest("pack1.Client", "Client");
+    doTest("xxx.Outer", "Outer");
+    doTest("p.A.B", "B");
+    doTest("p.A", "A");
+    doTest("p.B", "B");
+    doTest("package2.InnerClass", "InnerClass");
+    doTest("package1.OuterClass", "OuterClass");
+    doTest("pack1.DImpl", "DImpl");
+    doTest("pack1.A", "A");
+    doTest("pack1.B", "B");
+    doTest("pack2.B", "B");
+    doTest("pack1.Outer", "Outer");
+    doTest("POne<Hooray<A>>", "POne");
+    doTest("Eff<POne<A>, A>", "Eff");
+    doTest("@SomeAnnotation", "SomeAnnotation");
+    doTest("pack2.OtherClass", "OtherClass");
+    doTest("pack1.ClassWithStaticMethod", "ClassWithStaticMethod");
+    doTest("bar.A", "A");
+    doTest("A.Inner", "Inner");
+    doTest("B.Inner", "Inner");
+    doTest("target.pack1.S1", "S1");
+    doTest("pack2.UsagesFromBoth", "UsagesFromBoth");
+    doTest("pack2.UsagesFromBoth2", "UsagesFromBoth2");
+    doTest("Parent<T>", "Parent");
+    doTest("Parent<String>", "Parent");
+    doTest("I<S>", "I");
+    doTest("Base<U>", "Base");
+    doTest("javax.swing.JTextField", "JTextField");
+    doTest("Test<Throwable>", "Test");
+    doTest("BaseTask<T, ForEachTask<T>>", "BaseTask");
+    doTest("pack1.List", "List");
+    doTest("pack2.Usage2", "Usage2");
+    doTest("pack2.Usage", "Usage");
+    doTest("pack1.ParentXXX", "ParentXXX");
+    doTest("pack1.Derived", "Derived");
+    doTest("pack1.Object", "Object");
+    doTest("renameCollisions.String", "String");
+    doTest("javax.swing.SwingConstants", "SwingConstants");
+    doTest("Holder<X>", "Holder");
+    doTest("MyEventListener<Object>", "MyEventListener");
+    doTest("foo.Builder", "Builder");
+    doTest("Test<A, B, C>", "Test");
+    doTest("B<TC>", "B");
+    doTest("A<TB>", "A");
+    doTest("A<TC>", "A");
+    doTest("pack1.AnInterface", "AnInterface");
+    doTest("pack1.AClass", "AClass");
+    doTest("pack2.Client", "Client");
+    doTest("Int<Xyz>", "Int");
+    doTest("Int<XInt>", "Int");
+    doTest("Factory<IntF>", "Factory");
+    doTest("Factory<Clazz>", "Factory");
+    doTest("LinkedList<Integer>", "LinkedList");
+    doTest("LinkedList<E, T>", "LinkedList");
+    doTest("LinkedList<E, Integer>", "LinkedList");
+    doTest("Map<Integer, Y>", "Map");
+    doTest("List<X>", "List");
+    doTest("Collection<X>", "Collection");
+    doTest("List<P>", "List");
+    doTest("C<String,Integer>", "C");
+    doTest("C<Integer, String,Integer>", "C");
+    doTest("C<Integer, String >", "C");
+    doTest("C<String, L<String>>", "C");
+    doTest("Subject<String>", "Subject");
+    doTest("Subject<SubjectFace, Set<Object>>", "Subject");
+    doTest("Subject<SubjectFace, java.util.Set<Object>>", "Subject");
+    doTest("X<U>", "X");
+    doTest("java.util.TreeMap.Entry", "Entry");
+    doTest("java.util.TreeMap.Entry<K,?>", "Entry");
+    doTest("java.util.TreeMap.Entry<K,V>", "Entry");
+    doTest("java.util.Comparator<? super K>", "Comparator");
+    doTest("WeighingComparable<T, Loc>", "WeighingComparable");
+    doTest("Key<ProximityWeigher>", "Key");
+    doTest("Weigher<String, ProximityLocation>", "Weigher");
+    doTest("Comparable<WeighingComparable<T, Loc>>", "Comparable");
+    doTest("p1.ParentWithProtected", "ParentWithProtected");
+    doTest("p1.SubjectWithSuper", "SubjectWithSuper");
+    doTest("p2.Usage", "Usage");
+    doTest("p1.ParentUniqueName", "ParentUniqueName");
+    doTest("p1.ChildCtor", "ChildCtor");
+    doTest("java.util.Comparator<String>", "Comparator");
+    doTest("Demo.MyParent", "MyParent");
+    doTest("A.MyActionListener", "MyActionListener");
+    doTest("Comparable<T>", "Comparable");
+    doTest("qqq.aaa.Yahoo", "Yahoo");
+    doTest("p1.C1", "C1");
+    doTest("zzz.bbb.QQQ", "QQQ");
+  }
+
+  @Test
+  public void shortNameWithTypeAnnotations() {
+    doTest("java.util.@NotAllowed Date", "Date");
+    doTest("@IllegalSyntax java.util.Date", "Date");
+    doTest("Map<@NonNull String, @NonEmpty List<@Readonly Document>>", "Map");
+    doTest("@NonEmpty @Readonly List<@Readonly String>", "List");
+    doTest("Map.@NonNull Entry", "Entry");
+    doTest("MyClass<@Immutable ? extends Comparable<MyClass>>", "MyClass");
+  }
+
+  private static void doTest(String referenceText, String shortName) {
+    assertEquals(shortName, PsiNameHelper.getShortClassName(referenceText));
+  }
+}

From 578c9f5723562c5842ea62cb4611f29d2de59a40 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 16:31:32 +0400
Subject: [PATCH 196/354] cleanup

---
 .../src/com/intellij/codeInspection/ex/ToolsImpl.java          | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInspection/ex/ToolsImpl.java b/platform/lang-impl/src/com/intellij/codeInspection/ex/ToolsImpl.java
index ec0f889526ef..4dba44b65b32 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/ex/ToolsImpl.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/ex/ToolsImpl.java
@@ -88,13 +88,12 @@ public class ToolsImpl implements Tools {
           return state.getTool();
         }
         else {
-          final DependencyValidationManager validationManager = DependencyValidationManager.getInstance(project);
           final NamedScope scope = state.getScope(project);
           if (scope != null) {
             final PackageSet packageSet = scope.getValue();
             if (packageSet != null) {
               final PsiFile containingFile = element.getContainingFile();
-              if (containingFile != null && packageSet.contains(containingFile, validationManager)) {
+              if (containingFile != null && packageSet.contains(containingFile, DependencyValidationManager.getInstance(project))) {
                 return state.getTool();
               }
             }

From 273d459749e56b1b2393bd229ff82397905410fb Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 17:05:47 +0400
Subject: [PATCH 197/354] PY-6287 Changes to settings of inspections applied
 via quickfix are not persisted

---
 .../codeInspection/InspectionProfile.java        | 16 ++++++++++++----
 .../intellij/codeInspection/ModifiableModel.java |  7 +++++++
 .../codeInspection/ex/InspectionProfileImpl.java | 16 ++++++++++++++++
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java b/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
index 0ddf5937e5ab..07766bacc783 100644
--- a/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
+++ b/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
@@ -21,6 +21,7 @@ import com.intellij.codeInsight.daemon.HighlightDisplayKey;
 import com.intellij.openapi.project.Project;
 import com.intellij.profile.Profile;
 import com.intellij.psi.PsiElement;
+import com.intellij.util.Consumer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -31,15 +32,19 @@ import org.jetbrains.annotations.Nullable;
 public interface InspectionProfile extends Profile {
 
   HighlightDisplayLevel getErrorLevel(@NotNull HighlightDisplayKey inspectionToolKey, PsiElement element);
-  
+
+  /**
+   * If you need to modify tool's settings, please use {@link #modifyProfile(com.intellij.util.Consumer)}
+   */
   InspectionProfileEntry getInspectionTool(@NotNull String shortName, @NotNull PsiElement element);
 
+  @Nullable
+  InspectionProfileEntry getInspectionTool(@NotNull String shortName);
+
   /** Returns (unwrapped) inspection */
   InspectionProfileEntry getUnwrappedTool(@NotNull String shortName, @NotNull PsiElement element);
 
-  @Nullable
-  @Deprecated
-  InspectionProfileEntry getInspectionTool(@NotNull String shortName);
+  void modifyProfile(Consumer<ModifiableModel> modelConsumer);
 
   /**
    * @param element context element
@@ -50,6 +55,9 @@ public interface InspectionProfile extends Profile {
 
   void cleanup(Project project);
 
+  /**
+   * @see #modifyProfile(com.intellij.util.Consumer)
+   */
   @NotNull
   ModifiableModel getModifiableModel();
 
diff --git a/platform/lang-api/src/com/intellij/codeInspection/ModifiableModel.java b/platform/lang-api/src/com/intellij/codeInspection/ModifiableModel.java
index 01ee7fb3e68f..4780f4054cf0 100644
--- a/platform/lang-api/src/com/intellij/codeInspection/ModifiableModel.java
+++ b/platform/lang-api/src/com/intellij/codeInspection/ModifiableModel.java
@@ -21,6 +21,7 @@ import com.intellij.codeInsight.daemon.HighlightDisplayKey;
 import com.intellij.profile.Profile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.scope.packageSet.NamedScope;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
@@ -65,8 +66,14 @@ public interface ModifiableModel extends Profile {
 
   void resetToEmpty();
 
+  /**
+   * @return {@link com.intellij.codeInspection.ex.InspectionToolWrapper}
+   * @see #getUnwrappedTool(String, com.intellij.psi.PsiElement)
+   */
   InspectionProfileEntry getInspectionTool(String shortName, PsiElement element);
 
+  InspectionProfileEntry getUnwrappedTool(@NotNull String shortName, @NotNull PsiElement element);
+
   InspectionProfileEntry[] getInspectionTools(PsiElement element);
 
   void copyFrom(InspectionProfile profile);
diff --git a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
index b60b58736eb3..f07f264c0a3a 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
@@ -38,6 +38,7 @@ import com.intellij.profile.codeInspection.InspectionProfileManager;
 import com.intellij.profile.codeInspection.SeverityProvider;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.scope.packageSet.NamedScope;
+import com.intellij.util.Consumer;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.StringInterner;
@@ -338,6 +339,18 @@ public class InspectionProfileImpl extends ProfileEx implements ModifiableModel,
     return tool instanceof InspectionToolWrapper ? ((InspectionToolWrapper)tool).getTool() : tool;
   }
 
+  @Override
+  public void modifyProfile(Consumer<ModifiableModel> modelConsumer) {
+    ModifiableModel model = getModifiableModel();
+    modelConsumer.consume(model);
+    try {
+      model.commit();
+    }
+    catch (IOException e) {
+      LOG.error(e);
+    }
+  }
+
   @Override
   @Nullable
   public InspectionProfileEntry getInspectionTool(@NotNull String shortName) {
@@ -812,6 +825,9 @@ public class InspectionProfileImpl extends ProfileEx implements ModifiableModel,
     getTools(toolId).moveScope(idx, dir);
   }
 
+  /**
+   * @return null if it has no base profile
+   */
   @Nullable
   private Map<String, Boolean> getDisplayLevelMap() {
     if (myBaseProfile == null) return null;

From 92cff41d7c0de0aa48ca965b31a04de62d841f92 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Tue, 26 Feb 2013 17:14:47 +0400
Subject: [PATCH 198/354] fix testdata

---
 .../testdata/highlighting/DelegatedMethodIsImplemented.groovy   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/groovy/testdata/highlighting/DelegatedMethodIsImplemented.groovy b/plugins/groovy/testdata/highlighting/DelegatedMethodIsImplemented.groovy
index de75449efb25..4969ff2a5a66 100644
--- a/plugins/groovy/testdata/highlighting/DelegatedMethodIsImplemented.groovy
+++ b/plugins/groovy/testdata/highlighting/DelegatedMethodIsImplemented.groovy
@@ -7,5 +7,5 @@ class A {
 }
 
 <error descr="Method 'foo' is not implemented">class Y implements X</error>{
-  def foo(X<?> x){}
+  def foo(X<String> x){}
 }
\ No newline at end of file

From d9f46bd581378513291dfa382e950c95a70a97f2 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 11:38:47 +0100
Subject: [PATCH 199/354] NPE

---
 java/java-psi-api/src/com/intellij/psi/LambdaUtil.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
index 2aabebcffc31..1c91e6e8066e 100644
--- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
@@ -750,7 +750,7 @@ public class LambdaUtil {
 
     public TypeParamsChecker(PsiElement expression, PsiClass aClass) {
       myClass = aClass;
-      PsiElement parent = expression.getParent();
+      PsiElement parent = expression != null ? expression.getParent() : null;
       while (parent instanceof PsiParenthesizedExpression) {
         parent = parent.getParent();
       }

From d20905d2d51f339005b6d65d29cb70ad784d7865 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 12:39:13 +0100
Subject: [PATCH 200/354] constructor refs: forbid default constructors for
 inner classes

---
 .../tree/java/PsiMethodReferenceExpressionImpl.java    |  9 +--------
 .../lambda/methodRef/DefaultConstructor.java           | 10 +++++-----
 2 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
index 9582820ca481..b999d0a02fa9 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
@@ -292,15 +292,8 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase
             if (containingClass.getConstructors().length == 0 &&
                 !containingClass.isEnum() &&
                 !containingClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
-              boolean hasReceiver = false;
-              final PsiType[] parameterTypes = signature.getParameterTypes();
-              
-              if (parameterTypes.length == 1 && PsiMethodReferenceUtil.isReceiverType(parameterTypes[0], containingClass, substitutor)) {
-                hasReceiver = true;
-              }
-              final boolean innerClassOuterClassReference = containingClass.getContainingClass() != null && !containingClass.hasModifierProperty(PsiModifier.STATIC);
               ClassCandidateInfo candidateInfo = null;
-              if ((containingClass.getContainingClass() == null || !isLocatedInStaticContext(containingClass)) && parameterTypes.length == 0 || hasReceiver && innerClassOuterClassReference) {
+              if ((containingClass.getContainingClass() == null || !isLocatedInStaticContext(containingClass)) && signature.getParameterTypes().length == 0) {
                 candidateInfo = new ClassCandidateInfo(containingClass, substitutor);
               }
               return candidateInfo == null ? JavaResolveResult.EMPTY_ARRAY : new JavaResolveResult[]{candidateInfo};
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/DefaultConstructor.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/DefaultConstructor.java
index 2098a358e320..25349976f249 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/DefaultConstructor.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/DefaultConstructor.java
@@ -13,24 +13,24 @@ class DefaultConstructor {
         }
         
         static void test1() {
-            I2<Inner, Outer> i2 = Inner :: new;
+            <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,DefaultConstructor.Outer>'">I2<Inner, Outer> i2 = Inner :: new;</error>
             <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,java.lang.String>'">I2<Inner, String> i2str = Inner :: new;</error>
         }
         
         void test2() {
             I1<Inner> i1 = Inner :: new;
             <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I1<java.lang.Integer>'">I1<Integer> i1Int = Inner :: new;</error>
-            I2<Inner, Outer> i2 =  Inner :: new;
+            <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,DefaultConstructor.Outer>'">I2<Inner, Outer> i2 =  Inner :: new;</error>
         }
     }
     
     static void test1() {
-        I2<Outer.Inner, Outer> i2 = Outer.Inner::new;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,DefaultConstructor.Outer>'">I2<Outer.Inner, Outer> i2 = Outer.Inner::new;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,java.lang.String>'">I2<Outer.Inner, String> i2str = Outer.Inner::new;</error>
     }
     
     void test2() {
-        I2<Outer.Inner, Outer> i2 = Outer.Inner::new;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,DefaultConstructor.Outer>'">I2<Outer.Inner, Outer> i2 = Outer.Inner::new;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor.I2<DefaultConstructor.Outer.Inner,java.lang.String>'">I2<Outer.Inner, String> i2str = Outer.Inner::new;</error>
     }
 }
@@ -76,7 +76,7 @@ class DefaultConstructor4 {
    public class Inner {}
    public static class StaticInner {}
    
-   static I i = Inner::new;
+   static <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor4.I'">I i = Inner::new;</error>
    static <error descr="Incompatible types. Found: '<method reference>', required: 'DefaultConstructor4.I1'">I1 i1 = StaticInner::new;</error>
    interface I {
      Inner foo(DefaultConstructor4 receiver);

From af83c60af86642d5925bdf18459597453cf1d726 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 12:49:17 +0100
Subject: [PATCH 201/354] constructor refs: forbid outer as implicit receiver
 in non-static inner class

---
 .../src/com/intellij/psi/PsiMethodReferenceUtil.java |  6 +-----
 .../methodRef/ConstructorRefInnerFromSuper.java      |  2 +-
 .../methodRef/ConstructorRefsInnerClasses.java       | 12 ++++++------
 3 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index bad09bfb098b..489173a3d7fe 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -176,11 +176,7 @@ public class PsiMethodReferenceUtil {
   }
 
   private static boolean isReceiverType(@Nullable PsiClass aClass, @Nullable PsiClass containingClass) {
-    while (containingClass != null) {
-      if (InheritanceUtil.isInheritorOrSelf(aClass, containingClass, true)) return true;
-      containingClass = containingClass.getContainingClass();
-    }
-    return false;
+    return InheritanceUtil.isInheritorOrSelf(aClass, containingClass, true);
   }
 
   public static boolean isReceiverType(PsiType receiverType, @Nullable PsiClass containingClass, PsiSubstitutor psiSubstitutor) {
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefInnerFromSuper.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefInnerFromSuper.java
index bf9e811bfd05..7c3bff9f386c 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefInnerFromSuper.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefInnerFromSuper.java
@@ -13,7 +13,7 @@ class MyTest {
         }
 
         void test() {
-            I var = Child.Inner::new;
+            <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest.Child.I'">I var = Child.Inner::new;</error>
         }
     }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefsInnerClasses.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefsInnerClasses.java
index 4ed4642bc449..a7c4abcc40d1 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefsInnerClasses.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ConstructorRefsInnerClasses.java
@@ -16,8 +16,8 @@ class NonStaticInner {
   static void call12(I2 s) {}
 
   static {
-    I1 i1 = NonStaticInner.Inner :: new;
-    call11(NonStaticInner.Inner :: new);
+    <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner.I1'">I1 i1 = NonStaticInner.Inner :: new;</error>
+    call11<error descr="'call11(NonStaticInner.I1)' in 'NonStaticInner' cannot be applied to '(<method reference>)'">(NonStaticInner.Inner :: new)</error>;
 
     <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner.I2'">I2 i2 = NonStaticInner.Inner :: new;</error>
     call12<error descr="'call12(NonStaticInner.I2)' in 'NonStaticInner' cannot be applied to '(<method reference>)'">(NonStaticInner.Inner :: new)</error>;
@@ -109,11 +109,11 @@ class NonStaticInner2 {
 
 
   static {
-     I1 i1 = NonStaticInner2.Inner :: new;
+     <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner2.I1'">I1 i1 = NonStaticInner2.Inner :: new;</error>
   }
 
   {
-     I1 i1 = NonStaticInner2.Inner :: new;
+     <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner2.I1'">I1 i1 = NonStaticInner2.Inner :: new;</error>
   }
 }
 
@@ -145,7 +145,7 @@ class NonStaticInner3 {
     }
 
     {
-        I3<Foo> b1 = Foo::new;
-        I4<Foo> b2 = Foo::new;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner3.I3<NonStaticInner3.Foo>'">I3<Foo> b1 = Foo::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'NonStaticInner3.I4<NonStaticInner3.Foo>'">I4<Foo> b2 = Foo::new;</error>
     }
 }

From ed8986937ead2591daf6bbf8f44bd30597488e82 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 14:16:08 +0100
Subject: [PATCH 202/354] method refs: compilation error when static method is
 accept through instance reference

---
 .../java/PsiMethodReferenceExpressionImpl.java    |  2 +-
 .../lambda/methodRef/AccessModifiers.java         |  2 +-
 .../lambda/methodRef/MethodRefMisc1.java          |  2 +-
 .../StaticMethodOnTypedClassReference.java        | 15 +++++++++++++++
 .../methodRef/TypeArgumentsOnMethodRefs.java      |  4 ++--
 .../daemon/lambda/MethodRefHighlightingTest.java  |  4 ++++
 6 files changed, 24 insertions(+), 5 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/StaticMethodOnTypedClassReference.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
index b999d0a02fa9..c2584a2a6227 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
@@ -420,7 +420,7 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase
           final boolean staticOrValidConstructorRef = psiMethod.hasModifierProperty(PsiModifier.STATIC) || validConstructorRef;
 
           if ((parameterTypes.length == signatureParameterTypes2.length || varArgs) && 
-              (!myBeginsWithReferenceType || staticOrValidConstructorRef || (psiMethod.isConstructor() && conflict.isStaticsScopeCorrect()))) {
+              (!(myBeginsWithReferenceType ^ staticOrValidConstructorRef) || (psiMethod.isConstructor() && conflict.isStaticsScopeCorrect()))) {
             boolean correct = true;
             for (int i = 0; i < parameterTypes.length; i++) {
               final PsiType type1 = subst.substitute(GenericsUtil.eliminateWildcards(parameterTypes[i]));
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
index 40b69484a1ed..bd61f39024cb 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
@@ -30,7 +30,7 @@ class AlienTest {
         <error descr="Incompatible types. Found: '<method reference>', required: 'AlienTest.IInt'">IInt i3 = MyTest::bar;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'AlienTest.IIntInt'">IIntInt i4 = MyTest::bar;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'AlienTest.IInt'">IInt i5 = MyTest::baz;</error>
-        IInt i6 = <error descr="'foo(int)' is not public in 'MyTest.Foo'. Cannot be accessed from outside package">MyTest.foo::foo</error>;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'AlienTest.IInt'">IInt i6 = MyTest.foo::foo;</error>
         IInt i7 = MyTest.<error descr="'MyTest.Foo' has private access in 'MyTest'">Foo</error>::foo;
     }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
index ece7a65b2eea..ddb720e57756 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
@@ -68,7 +68,7 @@ class MyTest3 {
    static void m() { }
 
    public static void main(String[] args) {
-      I s = new MyTest3()::m;
+      <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest3.I'">I s = new MyTest3()::m;</error>
    }
 }
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/StaticMethodOnTypedClassReference.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/StaticMethodOnTypedClassReference.java
new file mode 100644
index 000000000000..85fd46e14b57
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/StaticMethodOnTypedClassReference.java
@@ -0,0 +1,15 @@
+class Test<X> {
+
+    interface I {
+      void _();
+    }
+
+    
+
+    void test() {
+      <error descr="Incompatible types. Found: '<method reference>', required: 'Test.I'">I i1 = Test<String>::foo;</error>
+      I i2 = Test::foo;
+    }
+
+    static void foo() { };
+}
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/TypeArgumentsOnMethodRefs.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/TypeArgumentsOnMethodRefs.java
index 1fe00da253a7..a420fd3fc05e 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/TypeArgumentsOnMethodRefs.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/TypeArgumentsOnMethodRefs.java
@@ -7,8 +7,8 @@ class Test<T> {
     Test test = new Test<String>();
     BlahBlah<String> blahBlah = test::<String>foo;
     BlahBlah<String> blahBlah1 = test::<String>foo1;
-    BlahBlah<String> blahBlah2 = test::<String>foo2;
-    BlahBlah<String> blahBlah3 = test::<String>foo3;
+    <error descr="Incompatible types. Found: '<method reference>', required: 'BlahBlah<java.lang.String>'">BlahBlah<String> blahBlah2 = test::<String>foo2;</error>
+    <error descr="Incompatible types. Found: '<method reference>', required: 'BlahBlah<java.lang.String>'">BlahBlah<String> blahBlah3 = test::<String>foo3;</error>
   }
 }
 
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index 5900b62e57a9..f9f3c34fe012 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -188,6 +188,10 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testStaticMethodOnTypedClassReference() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From b83dc56a2fee57b42497bd80d94da2ba4d456591 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Tue, 26 Feb 2013 17:25:09 +0400
Subject: [PATCH 203/354] [hg] Fix plugin.xml: remove the app service which has
 been deleted

---
 plugins/hg4idea/src/META-INF/plugin.xml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/plugins/hg4idea/src/META-INF/plugin.xml b/plugins/hg4idea/src/META-INF/plugin.xml
index ed0249f9993c..ef53adfcd3d5 100644
--- a/plugins/hg4idea/src/META-INF/plugin.xml
+++ b/plugins/hg4idea/src/META-INF/plugin.xml
@@ -21,8 +21,6 @@
                     serviceImplementation="org.zmlx.hg4idea.HgRootsHandler" />
     <projectService serviceInterface="org.zmlx.hg4idea.HgRememberedInputs"
                             serviceImplementation="org.zmlx.hg4idea.HgRememberedInputs"/>
-    <applicationService serviceInterface="org.zmlx.hg4idea.HgPlatformFacade"
-                        serviceImplementation="org.zmlx.hg4idea.HgPlatformFacadeImpl"/>
   </extensions>
 
   <project-components>

From a456f77736f0d224dd7e9e8ff232bbd36682ccbd Mon Sep 17 00:00:00 2001
From: Alexander Lobas <Alexander.Lobas@jetbrains.com>
Date: Tue, 26 Feb 2013 17:46:42 +0400
Subject: [PATCH 204/354] Support tabs for PropertyTablePanel

---
 .../designer/propertyTable/PropertyTablePanel.java       | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/PropertyTablePanel.java b/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/PropertyTablePanel.java
index fbf28c2e34ef..182fbaf6c7da 100644
--- a/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/PropertyTablePanel.java
+++ b/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/PropertyTablePanel.java
@@ -149,9 +149,14 @@ public final class PropertyTablePanel extends JPanel implements ListSelectionLis
       myActionPolicy = policy;
 
       for (AnAction action : myActions) {
-        JComponent button = (JComponent)action.getTemplatePresentation().getClientProperty(BUTTON_KEY);
+        boolean visible = policy.showAction(action);
+
+        Presentation presentation = action.getTemplatePresentation();
+        presentation.setVisible(visible);
+
+        JComponent button = (JComponent)presentation.getClientProperty(BUTTON_KEY);
         if (button != null) {
-          button.setVisible(policy.showAction(action));
+          button.setVisible(visible);
         }
       }
 

From 9f77f11db07a1050ee2397fb466e39384f3f8b14 Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Tue, 26 Feb 2013 17:56:19 +0400
Subject: [PATCH 205/354] WEB-6827 Emmet "Surround with Live Template" creating
 wrong element

---
 .../codeInsight/template/emmet/XmlEmmetParser.java     |  5 ++++-
 .../codeInsight/template/emmet/ZenCodingTemplate.java  | 10 +++++-----
 .../template/emmet/generators/ZenCodingGenerator.java  |  7 +++++--
 3 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
index 25d7ddd9c673..4b770f103bd1 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
@@ -75,10 +75,13 @@ public class XmlEmmetParser extends EmmetParser {
 
   public XmlEmmetParser(List<ZenCodingToken> tokens,
                         CustomTemplateCallback callback,
-                        ZenCodingGenerator generator) {
+                        ZenCodingGenerator generator, boolean surroundWithTemplate) {
     super(tokens, callback, generator);
     PsiElement context = callback.getContext();
     XmlTag parentTag = PsiTreeUtil.getParentOfType(context, XmlTag.class);
+    if (surroundWithTemplate && parentTag != null) {
+      parentTag = PsiTreeUtil.getParentOfType(parentTag, XmlTag.class);
+    }
     if (parentTag != null) {
       hasTagContext = true;
       tagLevel.push(parentTag.getName());
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
index 5d3ab8730412..3e2280e1de13 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/ZenCodingTemplate.java
@@ -67,7 +67,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
   @Nullable
   private static ZenCodingNode parse(@NotNull String text,
                                      @NotNull CustomTemplateCallback callback,
-                                     @NotNull ZenCodingGenerator generator) {
+                                     @NotNull ZenCodingGenerator generator, @Nullable String surroundedText) {
     List<ZenCodingToken> tokens = new EmmetLexer().lex(text);
     if (tokens == null) {
       return null;
@@ -75,7 +75,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
     if (!validate(tokens, generator)) {
       return null;
     }
-    EmmetParser parser = generator.createParser(tokens, callback, generator);
+    EmmetParser parser = generator.createParser(tokens, callback, generator, surroundedText != null);
     ZenCodingNode node = parser.parse();
     if (parser.getIndex() != tokens.size() || node instanceof TextNode) {
       return null;
@@ -93,7 +93,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
   }
 
   public static boolean checkTemplateKey(@NotNull String key, CustomTemplateCallback callback, @NotNull ZenCodingGenerator generator) {
-    return parse(key, callback, generator) != null;
+    return parse(key, callback, generator, null) != null;
   }
 
   public void expand(String key, @NotNull CustomTemplateCallback callback) {
@@ -158,7 +158,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
                              @NotNull CustomTemplateCallback callback,
                              String surroundedText,
                              @NotNull ZenCodingGenerator defaultGenerator) {
-    ZenCodingNode node = parse(key, callback, defaultGenerator);
+    ZenCodingNode node = parse(key, callback, defaultGenerator, surroundedText);
     assert node != null;
     if (surroundedText == null) {
       if (node instanceof TemplateNode) {
@@ -298,7 +298,7 @@ public class ZenCodingTemplate implements CustomLiveTemplate {
         CommandProcessor.getInstance().executeCommand(callback.getProject(), new Runnable() {
           public void run() {
             callback.fixInitialState(true);
-            ZenCodingNode node = parse(abbreviation, callback, defaultGenerator);
+            ZenCodingNode node = parse(abbreviation, callback, defaultGenerator, selection);
             assert node != null;
             PsiElement context = callback.getContext();
             ZenCodingGenerator generator = findApplicableGenerator(node, context, true);
diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/generators/ZenCodingGenerator.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/generators/ZenCodingGenerator.java
index f4a53d740bf9..2323619d10fb 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/generators/ZenCodingGenerator.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/generators/ZenCodingGenerator.java
@@ -159,7 +159,10 @@ public abstract class ZenCodingGenerator {
   }
 
   @NotNull
-  public EmmetParser createParser(List<ZenCodingToken> tokens, CustomTemplateCallback callback, ZenCodingGenerator generator) {
-    return new XmlEmmetParser(tokens, callback, generator);
+  public EmmetParser createParser(List<ZenCodingToken> tokens,
+                                  CustomTemplateCallback callback,
+                                  ZenCodingGenerator generator,
+                                  boolean surroundWithTemplate) {
+    return new XmlEmmetParser(tokens, callback, generator, surroundWithTemplate);
   }
 }

From 6b3c99293e5f060487e020024071940893d941d3 Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Tue, 26 Feb 2013 18:44:19 +0400
Subject: [PATCH 206/354] WEB-5939 Unexpected comment if add a new line before
 noncommented code and the previous line was commented

---
 .../editorActions/enter/BaseIndentEnterHandler.java         | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/BaseIndentEnterHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/BaseIndentEnterHandler.java
index 982cdb4b6e14..77b7e65a0033 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/BaseIndentEnterHandler.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/editorActions/enter/BaseIndentEnterHandler.java
@@ -109,7 +109,7 @@ public class BaseIndentEnterHandler extends EnterHandlerDelegateAdapter {
     final int previousLineStartOffset = lineNumber > 0 ? document.getLineStartOffset(lineNumber - 1) : lineStartOffset;
     final EditorHighlighter highlighter = ((EditorEx)editor).getHighlighter();
     final HighlighterIterator iterator = highlighter.createIterator(caret - 1);
-    final IElementType type = getNonWhitespaceElementType(iterator, previousLineStartOffset);
+    final IElementType type = getNonWhitespaceElementType(iterator, lineStartOffset, previousLineStartOffset);
 
     final CharSequence editorCharSequence = document.getCharsSequence();
     final CharSequence lineIndent =
@@ -190,8 +190,8 @@ public class BaseIndentEnterHandler extends EnterHandlerDelegateAdapter {
   }
 
   @Nullable
-  private IElementType getNonWhitespaceElementType(final HighlighterIterator iterator, final int lineStartOffset) {
-    while (!iterator.atEnd() && iterator.getStart() >= lineStartOffset) {
+  private IElementType getNonWhitespaceElementType(final HighlighterIterator iterator, int currentLineStartOffset, final int prevLineStartOffset) {
+    while (!iterator.atEnd() && iterator.getEnd() >= currentLineStartOffset && iterator.getStart() >= prevLineStartOffset) {
       final IElementType tokenType = iterator.getTokenType();
       if (!myWhitespaceTokens.contains(tokenType)) {
         return tokenType;

From 4eaa2c764a454dfdd025393be7d9ef09ceddf07e Mon Sep 17 00:00:00 2001
From: Evgeny Pasynkov <Evgeny.Pasynkov@jetbrains.com>
Date: Tue, 26 Feb 2013 15:59:04 +0100
Subject: [PATCH 207/354] stuff made public for Upsource

---
 .../com/intellij/openapi/roots/impl/DirectoryInfo.java   | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
index fd9cfdd86d57..ffb2ff30e797 100644
--- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
+++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryInfo.java
@@ -58,9 +58,10 @@ public final class DirectoryInfo {
    */
   private final OrderEntry[] orderEntries;
 
-  static DirectoryInfo createNew() {
+  public static DirectoryInfo createNew() {
     return new DirectoryInfo(null, null, null, null, (byte)0, null);
   }
+
   private DirectoryInfo(Module module,
                         VirtualFile contentRoot,
                         VirtualFile sourceRoot,
@@ -261,7 +262,7 @@ public final class DirectoryInfo {
     }
   };
 
-  static final Comparator<OrderEntry> BY_OWNER_MODULE = new Comparator<OrderEntry>() {
+  public static final Comparator<OrderEntry> BY_OWNER_MODULE = new Comparator<OrderEntry>() {
     @Override
     public int compare(OrderEntry o1, OrderEntry o2) {
       String name1 = o1.getOwnerModule().getName();
@@ -311,7 +312,7 @@ public final class DirectoryInfo {
   }
 
   @NotNull
-  DirectoryInfo with(Module module,
+  public DirectoryInfo with(Module module,
                             VirtualFile contentRoot,
                             VirtualFile sourceRoot,
                             VirtualFile libraryClassRoot,
@@ -323,7 +324,7 @@ public final class DirectoryInfo {
   }
 
   @NotNull
-  DirectoryInfo withInternedEntries(@NotNull OrderEntry[] orderEntries) {
+  public DirectoryInfo withInternedEntries(@NotNull OrderEntry[] orderEntries) {
     return new DirectoryInfo(module, contentRoot, sourceRoot, libraryClassRoot, sourceFlag, orderEntries);
   }
 

From 7c8abe817eecf568b91be32cb9bff9f854e571e1 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Tue, 26 Feb 2013 15:57:29 +0100
Subject: [PATCH 208/354] fix icons

---
 platform/core-api/src/com/intellij/ui/RowIcon.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/core-api/src/com/intellij/ui/RowIcon.java b/platform/core-api/src/com/intellij/ui/RowIcon.java
index b8c9372069e0..988b1b0e1248 100644
--- a/platform/core-api/src/com/intellij/ui/RowIcon.java
+++ b/platform/core-api/src/com/intellij/ui/RowIcon.java
@@ -1,6 +1,6 @@
 
 /*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -31,7 +31,7 @@ public class RowIcon implements Icon {
   private int myHeight;
 
   public RowIcon(int iconCount/*, int orientation*/) {
-    this(iconCount, Alignment.CENTER);
+    this(iconCount, Alignment.TOP);
   }
 
   public RowIcon(int iconCount, Alignment alignment) {

From 0a2f5908e45d1c9264918000fc3c6eccc5ab66ee Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Tue, 26 Feb 2013 16:10:30 +0100
Subject: [PATCH 209/354] don't forget about Y param

---
 platform/core-api/src/com/intellij/ui/RowIcon.java | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/platform/core-api/src/com/intellij/ui/RowIcon.java b/platform/core-api/src/com/intellij/ui/RowIcon.java
index 988b1b0e1248..ffd75097dd35 100644
--- a/platform/core-api/src/com/intellij/ui/RowIcon.java
+++ b/platform/core-api/src/com/intellij/ui/RowIcon.java
@@ -68,9 +68,12 @@ public class RowIcon implements Icon {
     for (Icon icon : myIcons) {
       if (icon == null) continue;
       switch (myAlignment) {
-        case TOP: _y = y;break;
-        case CENTER: _y = (myHeight - icon.getIconHeight())/2;break;
-        case BOTTOM: _y = (myHeight - icon.getIconHeight());break;
+        case TOP: _y = y;
+          break;
+        case CENTER: _y = y + (myHeight - icon.getIconHeight())/2;
+          break;
+        case BOTTOM: _y = y + (myHeight - icon.getIconHeight());
+          break;
       }
       icon.paintIcon(c, g, _x, _y);
       _x += icon.getIconWidth();

From 96abac54cc9ec475c8474e84166c835e14085ca6 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 15:02:33 +0100
Subject: [PATCH 210/354] method refs: treat boxed types as with anonymous

---
 .../com/intellij/psi/util/TypeConversionUtil.java | 15 ---------------
 .../lambda/methodRef/MethodRefMisc1.java          |  4 ++--
 2 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
index a206a642e396..a44600573970 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
@@ -815,21 +815,6 @@ public class TypeConversionUtil {
   }
 
   public static boolean boxingConversionApplicable(final PsiType left, final PsiType right) {
-    if (right instanceof PsiMethodReferenceType) {
-      final JavaResolveResult result = ((PsiMethodReferenceType)right).getExpression().advancedResolve(false);
-      PsiElement element = result.getElement();
-      final PsiClassType.ClassResolveResult functionalInterfaceResult = PsiUtil.resolveGenericsClassInType(left);
-      final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceResult);
-      if (element instanceof PsiMethod && interfaceMethod != null) {
-        final PsiType[] parameterTypes = ((PsiMethod)element).getSignature(result.getSubstitutor()).getParameterTypes();
-        final PsiType[] argTypes = interfaceMethod.getSignature(functionalInterfaceResult.getSubstitutor()).getParameterTypes();
-        if (parameterTypes.length != argTypes.length) return false;
-        for (int i = 0; i < parameterTypes.length; i++) {
-          if (boxingConversionApplicable(parameterTypes[i], argTypes[i])) return true;
-        }
-      }
-    }
-
     if (left instanceof PsiPrimitiveType && !PsiType.NULL.equals(left)) {
       return right instanceof PsiClassType && isAssignable(left, right);
     }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
index ddb720e57756..36fc91f8e8cd 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefMisc1.java
@@ -38,7 +38,7 @@ class MyTest1 {
     }
 
     public static void main(String[] args) {
-        call(1, MyTest1::m);
+        call<error descr="Ambiguous method call: both 'MyTest1.call(int, I1)' and 'MyTest1.call(int, I2)' match">(1, MyTest1::m)</error>;
     }
 }
 
@@ -54,7 +54,7 @@ class MyTest2 {
     static void call(Integer i, I s) {   }
 
     static void test() {
-        call<error descr="Ambiguous method call: both 'MyTest2.call(int, I)' and 'MyTest2.call(Integer, I)' match">(1, MyTest2::m)</error>; //ambiguous
+        call(1, MyTest2::m); //call(int i, I s)
     }
 }
 

From a41b5c6f8589102f55a83d4044893c9a1f6bcdb6 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 16:10:26 +0100
Subject: [PATCH 211/354] support method/constructor refs on array types

---
 .../intellij/psi/PsiMethodReferenceUtil.java  | 37 +++++++++++++------
 .../PsiMethodReferenceExpressionImpl.java     |  3 +-
 .../methodRef/RefOnArrayDeclaration.java      | 33 +++++++++++++++++
 .../lambda/MethodRefHighlightingTest.java     |  4 ++
 4 files changed, 65 insertions(+), 12 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index 489173a3d7fe..070d42f58664 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -16,11 +16,13 @@
 package com.intellij.psi;
 
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.util.InheritanceUtil;
 import com.intellij.psi.util.MethodSignature;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.psi.util.TypeConversionUtil;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.HashMap;
@@ -101,7 +103,8 @@ public class PsiMethodReferenceUtil {
     else {
       final PsiTypeElement typeElement = methodReferenceExpression.getQualifierType();
       if (typeElement != null) {
-        PsiClassType.ClassResolveResult result = PsiUtil.resolveGenericsClassInType(typeElement.getType());
+        PsiType type = getExpandedType(typeElement.getType(), typeElement);
+        PsiClassType.ClassResolveResult result = PsiUtil.resolveGenericsClassInType(type);
         containingClass = result.getElement();
         if (containingClass != null) {
           substitutor = result.getSubstitutor();
@@ -180,6 +183,9 @@ public class PsiMethodReferenceUtil {
   }
 
   public static boolean isReceiverType(PsiType receiverType, @Nullable PsiClass containingClass, PsiSubstitutor psiSubstitutor) {
+    if (containingClass != null) {
+      receiverType = getExpandedType(receiverType, containingClass);
+    }
     final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(GenericsUtil.eliminateWildcards(receiverType));
     final PsiClass receiverClass = resolveResult.getElement();
     if (receiverClass != null && isReceiverType(receiverClass, containingClass)) {
@@ -260,14 +266,23 @@ public class PsiMethodReferenceUtil {
     return true;
   }
 
-  public static PsiLocalVariable createMethodReferenceExpressionAccording2Type(PsiMethodReferenceExpression methodReferenceExpression,
-                                                                               PsiType leftType) {
-    final String uniqueVarName =
-      JavaCodeStyleManager.getInstance(methodReferenceExpression.getProject())
-        .suggestUniqueVariableName("l", methodReferenceExpression, true);
-    final PsiStatement assignmentFromText = JavaPsiFacade.getElementFactory(methodReferenceExpression.getProject())
-      .createStatementFromText(leftType.getCanonicalText() + " " + uniqueVarName + " = " + methodReferenceExpression.getText(),
-                               methodReferenceExpression);
-    return (PsiLocalVariable)((PsiDeclarationStatement)assignmentFromText).getDeclaredElements()[0];
+
+  public static boolean onArrayType(PsiClass containingClass, MethodSignature signature) {
+    if (signature.getParameterTypes().length == 1 && signature.getParameterTypes()[0] == PsiType.INT) {
+      if (containingClass != null) {
+        final Project project = containingClass.getProject();
+        final LanguageLevel level = PsiUtil.getLanguageLevel(containingClass);
+        return containingClass == JavaPsiFacade.getElementFactory(project).getArrayClass(level);
+      }
+    }
+    return false;
+  }
+
+  private static PsiType getExpandedType(PsiType type, @NotNull PsiElement typeElement) {
+    if (type instanceof PsiArrayType) {
+      type = JavaPsiFacade.getElementFactory(typeElement.getProject()).getArrayClassType(((PsiArrayType)type).getComponentType(),
+                                                                                         PsiUtil.getLanguageLevel(typeElement));
+    }
+    return type;
   }
 }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
index c2584a2a6227..810e541cb387 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodReferenceExpressionImpl.java
@@ -293,7 +293,8 @@ public class PsiMethodReferenceExpressionImpl extends PsiReferenceExpressionBase
                 !containingClass.isEnum() &&
                 !containingClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
               ClassCandidateInfo candidateInfo = null;
-              if ((containingClass.getContainingClass() == null || !isLocatedInStaticContext(containingClass)) && signature.getParameterTypes().length == 0) {
+              if ((containingClass.getContainingClass() == null || !isLocatedInStaticContext(containingClass)) && signature.getParameterTypes().length == 0 ||
+                  PsiMethodReferenceUtil.onArrayType(containingClass, signature)) {
                 candidateInfo = new ClassCandidateInfo(containingClass, substitutor);
               }
               return candidateInfo == null ? JavaResolveResult.EMPTY_ARRAY : new JavaResolveResult[]{candidateInfo};
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
new file mode 100644
index 000000000000..c4e45cec4c0c
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
@@ -0,0 +1,33 @@
+class OnArrayTest {
+
+    interface Cln {
+       Object m(int[] i);
+    }
+
+    interface IA {
+        void m(int i);
+    }
+
+    interface I {
+        void m(int[] i);
+    }
+
+    interface Len<T> {
+        int len(T[] ta);
+    }
+
+
+    interface ToStr<T> {
+        String _(T[] ta);
+    }
+
+
+
+    public static void main(String[] args) {
+        Cln s =  int[]::clone;
+        IA a =  int[]::new;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.I'">I i = int[]::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.Len<java.lang.String>'">Len<String> strLen = String[]::length;</error>
+        ToStr<Integer> toStr = Integer[]::toString;
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index f9f3c34fe012..526c855784b6 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -192,6 +192,10 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testRefOnArrayDeclaration() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From 456a49ce9f9240e648f46cdfd813d82adfbad07d Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 16:25:57 +0100
Subject: [PATCH 212/354] method refs: fix testdata according to new javac
 strategy

---
 ...fterConstructorReceiverNonStaticInner.java | 13 --------
 .../afterConstructorRef3.java                 | 33 -------------------
 .../afterConstructorRef4.java                 | 33 -------------------
 ...foreConstructorReceiverNonStaticInner.java |  2 +-
 .../beforeConstructorRef3.java                |  2 +-
 .../beforeConstructorRef4.java                |  2 +-
 .../types/methodRefs2lambda/Ambiguity.java    |  2 +-
 .../methodRefs2lambda/Ambiguity_after.java    |  4 +--
 .../NewDefaultConstructor.java                |  6 ++--
 .../NewDefaultConstructor_after.java          |  8 +++--
 .../methodRefs2lambda/NewRefsInnerClass.java  |  4 +--
 .../NewRefsInnerClass_after.java              |  6 ++--
 .../TypeElementOnTheLeft.java                 |  2 +-
 13 files changed, 21 insertions(+), 96 deletions(-)
 delete mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorReceiverNonStaticInner.java
 delete mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef3.java
 delete mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef4.java

diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorReceiverNonStaticInner.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorReceiverNonStaticInner.java
deleted file mode 100644
index 56cc62b97441..000000000000
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorReceiverNonStaticInner.java
+++ /dev/null
@@ -1,13 +0,0 @@
-// "Replace lambda with method reference" "true"
-class NonStaticInner {
-  class Inner {
-    Inner() {}
-  }
-
-  interface I1 {
-    Inner m(NonStaticInner rec);
-  }
-  static {
-    I1 i1 = Inner::new;
-  }
-}
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef3.java
deleted file mode 100644
index ae02fa4df561..000000000000
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef3.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// "Replace lambda with method reference" "true"
-class NonStaticInner3 {
-    class Foo {
-        Foo(Integer i) {}
-        Foo() {}
-    }
-
-    interface I1<X> {
-        X m(int i);
-    }
-
-    interface I2<X> {
-        X m();
-    }
-
-    interface I3<X> {
-        X m(NonStaticInner3 rec, int i);
-    }
-
-    interface I4<X> {
-        X m(NonStaticInner3 rec);
-    }
-
-    {
-        I1<Foo> b1 = (i) -> new Foo(i);
-        I2<Foo> b2 = () -> new Foo();
-    }
-
-    {
-        I3<Foo> b1 = Foo::new;
-        I4<Foo> b2 = (rec) -> rec.new Foo();
-    }
-}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef4.java
deleted file mode 100644
index 159685e69b9c..000000000000
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/afterConstructorRef4.java
+++ /dev/null
@@ -1,33 +0,0 @@
-// "Replace lambda with method reference" "true"
-class NonStaticInner3 {
-    class Foo {
-        Foo(Integer i) {}
-        Foo() {}
-    }
-
-    interface I1<X> {
-        X m(int i);
-    }
-
-    interface I2<X> {
-        X m();
-    }
-
-    interface I3<X> {
-        X m(NonStaticInner3 rec, int i);
-    }
-
-    interface I4<X> {
-        X m(NonStaticInner3 rec);
-    }
-
-    {
-        I1<Foo> b1 = (i) -> new Foo(i);
-        I2<Foo> b2 = () -> new Foo();
-    }
-
-    {
-        I3<Foo> b1 = (rec, i) -> rec.new Foo(i);
-        I4<Foo> b2 = Foo::new;
-    }
-}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorReceiverNonStaticInner.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorReceiverNonStaticInner.java
index 70c2300487f6..e869745a7879 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorReceiverNonStaticInner.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorReceiverNonStaticInner.java
@@ -1,4 +1,4 @@
-// "Replace lambda with method reference" "true"
+// "Replace lambda with method reference" "false"
 class NonStaticInner {
   class Inner {
     Inner() {}
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef3.java
index e1c181a14f0c..3520a79ea9bb 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef3.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef3.java
@@ -1,4 +1,4 @@
-// "Replace lambda with method reference" "true"
+// "Replace lambda with method reference" "false"
 class NonStaticInner3 {
     class Foo {
         Foo(Integer i) {}
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef4.java
index 2e6134230298..2bc1973fe85f 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef4.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambda2methodReference/beforeConstructorRef4.java
@@ -1,4 +1,4 @@
-// "Replace lambda with method reference" "true"
+// "Replace lambda with method reference" "false"
 class NonStaticInner3 {
     class Foo {
         Foo(Integer i) {}
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity.java
index f4b0d1c1772c..fa682838ad8e 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity.java
@@ -10,7 +10,7 @@ public class MyTest {
         void m(Integer x);
     }
 
-    static void call(int i, I1 s) {}
+    static void call(Integer i, I1 s) {}
     static void call(int i, I2 s) {}
 
     public static void main(String[] args) {
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity_after.java
index cadb53a71c48..b0e14f13dad8 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity_after.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/Ambiguity_after.java
@@ -10,10 +10,10 @@ public class MyTest {
         void m(Integer x);
     }
 
-    static void call(int i, I1 s) {}
+    static void call(Integer i, I1 s) {}
     static void call(int i, I2 s) {}
 
     public static void main(String[] args) {
-        call(1, (I2) (x) -> MyTest.m(x));
+        call(1, (x) -> MyTest.m(x));
     }
 }
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor.java
index 3dc2facab3c4..3e4e1727b067 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor.java
@@ -1,10 +1,12 @@
 class Test1 {
-    class Inner {}
+        static class Inner {
+        }
+
         void test() {
         BlahBlah6 blahBlah62 = Inner:<caret>:new;
         }
 }
 
 interface BlahBlah6 {
-    Test1.Inner foo6(Test1 p);
+    Test1.Inner foo6();
 }
\ No newline at end of file
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor_after.java
index f346d7d7a18c..0183b2009c60 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor_after.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewDefaultConstructor_after.java
@@ -1,10 +1,12 @@
 class Test1 {
-    class Inner {}
+        static class Inner {
+        }
+
         void test() {
-        BlahBlah6 blahBlah62 = (p) -> p.new Inner();
+        BlahBlah6 blahBlah62 = () -> new Inner();
         }
 }
 
 interface BlahBlah6 {
-    Test1.Inner foo6(Test1 p);
+    Test1.Inner foo6();
 }
\ No newline at end of file
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass.java
index 3a28070d1db5..985c9a4a3094 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass.java
@@ -1,6 +1,6 @@
 class MyTest {
-    class Inner {
-        Inner() {};
+    static class Inner {
+        Inner(MyTest mt) {};
     }
   
     interface I {
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass_after.java
index 661cf589b482..600af263857a 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass_after.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/NewRefsInnerClass_after.java
@@ -1,6 +1,6 @@
 class MyTest {
-    class Inner {
-        Inner() {};
+    static class Inner {
+        Inner(MyTest mt) {};
     }
   
     interface I {
@@ -8,6 +8,6 @@ class MyTest {
     }
 
     static {
-        I i1 = (receiver) -> receiver.new Inner();
+        I i1 = (receiver) -> new Inner(receiver);
     }
 }
diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/TypeElementOnTheLeft.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/TypeElementOnTheLeft.java
index f3549e6c0c9c..4bb8270dc216 100644
--- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/TypeElementOnTheLeft.java
+++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/methodRefs2lambda/TypeElementOnTheLeft.java
@@ -4,6 +4,6 @@ class Test<T> {
 
 class Bar {
   void test() {
-    Runnable runnable = Test<String>:<caret>:foo;
+    Runnable runnable = Test:<caret>:foo;
   }
 }
\ No newline at end of file

From a914af49becf5c23ee1f1432d7712fafcebd9e39 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Tue, 26 Feb 2013 19:31:01 +0400
Subject: [PATCH 213/354] IDEA-101547 Please add a clock in fullscreen mode!

---
 .../intellij/openapi/wm/impl/IdeRootPane.java |   2 +
 .../openapi/wm/impl/status/ClockPanel.java    | 166 ++++++++++++++++++
 2 files changed, 168 insertions(+)
 create mode 100644 platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
index 45b4782c11dc..bcde70075ada 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
@@ -35,6 +35,7 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.impl.status.ClockPanel;
 import com.intellij.openapi.wm.impl.status.IdeStatusBarImpl;
 import com.intellij.openapi.wm.impl.status.MemoryUsagePanel;
 import com.intellij.ui.JBColor;
@@ -256,6 +257,7 @@ public class IdeRootPane extends JRootPane implements UISettingsListener {
     }
 
     myStatusBar.addWidget(myMemoryWidget);
+    myStatusBar.addWidget(new ClockPanel(), "after " + MemoryUsagePanel.WIDGET_ID);
     myStatusBar.addWidget(new IdeMessagePanel(MessagePool.getInstance()), "before " + MemoryUsagePanel.WIDGET_ID);
 
     setMemoryIndicatorVisible(myUISettings.SHOW_MEMORY_INDICATOR);
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
new file mode 100644
index 000000000000..0a6d89d813ca
--- /dev/null
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2000-2013 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.openapi.wm.impl.status;
+
+import com.intellij.openapi.wm.CustomStatusBarWidget;
+import com.intellij.openapi.wm.IdeFrame;
+import com.intellij.openapi.wm.StatusBar;
+import com.intellij.openapi.wm.impl.IdeFrameImpl;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Line2D;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+
+import static java.awt.RenderingHints.KEY_ANTIALIASING;
+import static java.util.Calendar.*;
+
+/**
+ * User: Vassiliy.Kudryashov
+ */
+public class ClockPanel extends JComponent implements CustomStatusBarWidget{
+  @NonNls public static final String WIDGET_ID = "Clock";
+
+  protected final Calendar myCalendar;
+  private final Timer myTimer;
+  private final boolean is24Hours;
+  private IdeFrameImpl myIdeFrame;
+
+  public ClockPanel() {
+    myCalendar = getInstance();
+    is24Hours = new SimpleDateFormat().toLocalizedPattern().contains("H");
+    myTimer = new Timer(50, new ActionListener() {
+      @Override
+      public void actionPerformed(ActionEvent e) {
+        repaint();
+      }
+    });
+  }
+
+  @NotNull
+  @Override
+  public String ID() {
+    return WIDGET_ID;
+  }
+
+  @Override
+  public void install(@NotNull StatusBar statusBar) {
+    IdeFrame frame = statusBar.getFrame();
+    myIdeFrame = frame instanceof IdeFrameImpl ? (IdeFrameImpl)frame : null;
+    myTimer.start();
+  }
+
+  @Override
+  public void dispose() {
+    myTimer.stop();
+    myIdeFrame = null;
+  }
+
+  @Override
+  public boolean isVisible() {
+    return myIdeFrame != null && myIdeFrame.isInFullScreen();
+  }
+
+  @Override
+  public JComponent getComponent() {
+    return this;
+  }
+
+  @Nullable
+  @Override
+  public WidgetPresentation getPresentation(@NotNull PlatformType type) {
+    return null;
+  }
+
+  @Override
+  public Dimension getPreferredSize() {
+    int height;
+    Container parent = getParent();
+    if (isVisible() && parent != null) {
+      height = parent.getSize().height - parent.getInsets().top - parent.getInsets().bottom;
+    } else {
+      height = super.getPreferredSize().height;
+    }
+    return new Dimension((int)(height * 2.75), height);
+  }
+
+  @Override
+  public Dimension getMaximumSize() {
+    return getPreferredSize();
+  }
+
+  @Override
+  public void paint(Graphics graphics) {
+    Graphics2D g = (Graphics2D) graphics.create();
+    try {
+      g.setRenderingHint(KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+      g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
+      int h = getHeight() - 4;
+      int w = h / 2;
+      float thickness = h * .1F;
+      g.setTransform(new AffineTransform(1, 0, -thickness / h, 1, thickness * 3, thickness / 4));
+      g.setStroke(new BasicStroke(thickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+      g.setColor(UIManager.getColor("Label.foreground"));
+      myCalendar.setTimeInMillis(System.currentTimeMillis());
+      int hours = myCalendar.get(is24Hours ? HOUR_OF_DAY : HOUR);
+      int minutes = myCalendar.get(MINUTE);
+      int x = 0;
+      int y = 2;
+      boolean eveningDot = !is24Hours && myCalendar.get(HOUR_OF_DAY) > 11;
+      if (eveningDot) {
+        g.setStroke(new BasicStroke(thickness*2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+        g.draw(new Line2D.Float(x + thickness, y + thickness, x+thickness, y + thickness + thickness / 20));
+      }
+      g.setStroke(new BasicStroke(thickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+      if (hours>=10 ) paintDigit(g, x, y, w, h, thickness, hours / 10);
+      x += w + thickness * 2;
+      paintDigit(g, x, y, w, h, thickness, hours % 10);
+      x += w + thickness * 2;
+      if (myCalendar.get(MILLISECOND) <= 500) {
+        g.draw(new Line2D.Float(x, y + h / 2 - thickness * 2, x, y + h / 2 - thickness * 2 + thickness / 20));
+        g.draw(new Line2D.Float(x, y + h / 2 + thickness * 2, x, y + h / 2 + thickness * 2 + thickness / 20));
+      }
+      x += thickness * 2;
+      paintDigit(g, x, y, w, h, thickness, minutes / 10);
+      x += w + thickness * 2;
+      paintDigit(g, x, y, w, h, thickness, minutes % 10);
+    } finally {
+      g.dispose();
+    }
+  }
+
+  private static void paintDigit(Graphics2D g, int x, int y, int width, int height, float t, int digit) {
+    digit = 1 << digit;
+    int h2 = height / 2;
+    float t54 = t * 5 / 4;
+    float t34 = t * 3 / 4;
+    float t2 = t / 2;
+    if ((digit & 1005) != 0) g.draw(new Line2D.Float(x + t54, y + t2, x + width - t54, y + t2));
+    if ((digit & 881) != 0) g.draw(new Line2D.Float(x + t2, y + t54, x + t2, y + h2 - t34));
+    if ((digit & 927) != 0) g.draw(new Line2D.Float(x + width - t2, y + t54, x + width - t2, y + h2 - t34));
+    if ((digit & 892) != 0) g.draw(new Line2D.Float(x + t54, y + h2, x + width - t54, y + h2));
+    if ((digit & 325) != 0) g.draw(new Line2D.Float(x + t2, y + h2 + t34, x + t2, y + height - t54));
+    if ((digit & 1019) != 0) g.draw(new Line2D.Float(x + width - t2, y + h2 + t34, x + width - t2, y + height - t54));
+    if ((digit & 877) != 0) g.draw(new Line2D.Float(x + t54, y + height - t2, x + width - t54, y + height - t2));
+  }
+}

From c092d7ea147c3b13f373c682a2d9239cdf6a854e Mon Sep 17 00:00:00 2001
From: Eugene Zhuravlev <jeka@intellij.com>
Date: Tue, 26 Feb 2013 16:36:15 +0100
Subject: [PATCH 214/354] external make: better diagnostic message for fully
 rebuilt modules

---
 .../jps/incremental/BuildOperations.java      | 14 +------
 .../jps/incremental/IncProjectBuilder.java    | 41 ++++++++++++++++++-
 .../storage/BuildTargetConfiguration.java     | 16 +++++++-
 3 files changed, 56 insertions(+), 15 deletions(-)

diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
index 25effec23dca..6f2015e88bc4 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/BuildOperations.java
@@ -22,13 +22,10 @@ import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.builders.impl.BuildOutputConsumerImpl;
 import org.jetbrains.jps.builders.impl.BuildTargetChunk;
 import org.jetbrains.jps.builders.impl.DirtyFilesHolderBase;
-import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
 import org.jetbrains.jps.builders.logging.ProjectBuilderLogger;
 import org.jetbrains.jps.builders.storage.SourceToOutputMapping;
 import org.jetbrains.jps.cmdline.ProjectDescriptor;
 import org.jetbrains.jps.incremental.fs.BuildFSState;
-import org.jetbrains.jps.incremental.messages.BuildMessage;
-import org.jetbrains.jps.incremental.messages.CompilerMessage;
 import org.jetbrains.jps.incremental.messages.DoneSomethingNotification;
 import org.jetbrains.jps.incremental.messages.FileDeletedEvent;
 import org.jetbrains.jps.incremental.storage.BuildDataManager;
@@ -51,25 +48,16 @@ public class BuildOperations {
     final ProjectDescriptor pd = context.getProjectDescriptor();
     final Timestamps timestamps = pd.timestamps.getStorage();
     final BuildTargetConfiguration configuration = pd.getTargetsState().getTargetConfiguration(target);
-    boolean isTargetConfigChange = false;
     if (context.isProjectRebuild()) {
       FSOperations.markDirtyFiles(context, target, timestamps, true, null, null);
       pd.fsState.markInitialScanPerformed(target);
       configuration.save();
     }
-    else if (context.getScope().isRecompilationForced(target) ||
-             (isTargetConfigChange = configuration.isTargetDirty()) ||
-             configuration.outputRootWasDeleted(context)) {
+    else if (context.getScope().isRecompilationForced(target) || configuration.isTargetDirty(context) || configuration.outputRootWasDeleted(context)) {
       initTargetFSState(context, target, true);
       IncProjectBuilder.clearOutputFiles(context, target);
       pd.dataManager.cleanTargetStorages(target);
       configuration.save();
-
-      if (isTargetConfigChange && ModuleBuildTarget.REBUILD_ON_DEPENDENCY_CHANGE && JavaModuleBuildTargetType.PRODUCTION.equals(target.getTargetType())) {
-        final String moduleName = ((ModuleBuildTarget)target).getModule().getName();
-        context.processMessage(new CompilerMessage("", BuildMessage.Kind.INFO, "Rebuilding module \"" + moduleName + "\" because of dependencies change"));
-      }
-
     }
     else if (!pd.fsState.isInitialScanPerformed(target)) {
       initTargetFSState(context, target, false);
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
index d8e4048a7ff1..d4f828572b68 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java
@@ -49,10 +49,12 @@ import org.jetbrains.jps.cmdline.ProjectDescriptor;
 import org.jetbrains.jps.incremental.fs.BuildFSState;
 import org.jetbrains.jps.incremental.java.ExternalJavacDescriptor;
 import org.jetbrains.jps.incremental.messages.*;
+import org.jetbrains.jps.incremental.storage.BuildTargetConfiguration;
 import org.jetbrains.jps.incremental.storage.OneToManyPathsMapping;
 import org.jetbrains.jps.indices.ModuleExcludeIndex;
 import org.jetbrains.jps.model.java.JpsJavaExtensionService;
 import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration;
+import org.jetbrains.jps.model.module.JpsModule;
 import org.jetbrains.jps.service.SharedThreadPool;
 import org.jetbrains.jps.util.JpsPathUtil;
 
@@ -177,6 +179,7 @@ public class IncProjectBuilder {
       context = createContext(scope, isMake, isProjectRebuild);
       runBuild(context, forceCleanCaches);
       myProjectDescriptor.dataManager.saveVersion();
+      reportRebuiltModules(context);
     }
     catch (ProjectBuildException e) {
       final Throwable cause = e.getCause();
@@ -191,8 +194,9 @@ public class IncProjectBuilder {
         throw new RebuildRequestedException(cause);
       }
       else {
+        reportRebuiltModules(context);
         if (cause == null) {
-          // some builder desided to stop the build
+          // some builder decided to stop the build
           // report optional progress message if exists
           final String msg = e.getMessage();
           if (!StringUtil.isEmpty(msg)) {
@@ -222,6 +226,41 @@ public class IncProjectBuilder {
     }
   }
 
+  private static void reportRebuiltModules(CompileContextImpl context) {
+    final Set<JpsModule> modules = BuildTargetConfiguration.MODULES_WITH_TARGET_CONFIG_CHANGED_KEY.get(context);
+    if (modules == null || modules.isEmpty()) {
+      return;
+    }
+    final StringBuilder message = new StringBuilder();
+    if (modules.size() > 1) {
+      message.append("Modules ");
+      final int namesLimit = 5;
+      int idx = 0;
+      for (Iterator<JpsModule> iterator = modules.iterator(); iterator.hasNext(); ) {
+        final JpsModule module = iterator.next();
+        if (idx == namesLimit && iterator.hasNext()) {
+          message.append(" and ").append(modules.size() - namesLimit).append(" others");
+          break;
+        }
+        if (idx > 0) {
+          message.append(", ");
+        }
+        message.append("\"").append(module.getName()).append("\"");
+        idx += 1;
+      }
+      message.append(" were");
+    }
+    else {
+      message.append("Module \"").append(modules.iterator().next().getName()).append("\" was");
+    }
+    message.append(" fully rebuilt due to project configuration");
+    if (ModuleBuildTarget.REBUILD_ON_DEPENDENCY_CHANGE) {
+      message.append("/dependencies");
+    }
+    message.append(" changes");
+    context.processMessage(new CompilerMessage("", BuildMessage.Kind.INFO, message.toString()));
+  }
+
   private static void flushContext(CompileContext context) {
     if (context != null) {
       final ProjectDescriptor pd = context.getProjectDescriptor();
diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildTargetConfiguration.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildTargetConfiguration.java
index 8067aefacd5c..8d926f89c273 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildTargetConfiguration.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildTargetConfiguration.java
@@ -16,6 +16,7 @@
 package org.jetbrains.jps.incremental.storage;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.SmartList;
@@ -23,6 +24,8 @@ import gnu.trove.THashSet;
 import org.jetbrains.jps.builders.BuildTarget;
 import org.jetbrains.jps.incremental.CompileContext;
 import org.jetbrains.jps.incremental.GlobalContextKey;
+import org.jetbrains.jps.incremental.ModuleBuildTarget;
+import org.jetbrains.jps.model.module.JpsModule;
 
 import java.io.*;
 import java.util.Collection;
@@ -34,6 +37,7 @@ import java.util.Set;
  * @author nik
  */
 public class BuildTargetConfiguration {
+  public static final Key<Set<JpsModule>> MODULES_WITH_TARGET_CONFIG_CHANGED_KEY = GlobalContextKey.create("_modules_with_target_config_changed_");
   private static final Logger LOG = Logger.getInstance(BuildTargetConfiguration.class);
   private final BuildTarget<?> myTarget;
   private final BuildTargetsState myTargetsState;
@@ -60,7 +64,7 @@ public class BuildTargetConfiguration {
     return "";
   }
 
-  public boolean isTargetDirty() {
+  public boolean isTargetDirty(CompileContext context) {
     final String currentState = getCurrentState();
     if (!currentState.equals(myConfiguration)) {
       LOG.debug(myTarget + " configuration was changed:");
@@ -69,6 +73,16 @@ public class BuildTargetConfiguration {
       LOG.debug("New:");
       LOG.debug(currentState);
       LOG.debug(myTarget + " will be recompiled");
+      if (myTarget instanceof ModuleBuildTarget) {
+        final JpsModule module = ((ModuleBuildTarget)myTarget).getModule();
+        synchronized (MODULES_WITH_TARGET_CONFIG_CHANGED_KEY) {
+          Set<JpsModule> modules = MODULES_WITH_TARGET_CONFIG_CHANGED_KEY.get(context);
+          if (modules == null) {
+            MODULES_WITH_TARGET_CONFIG_CHANGED_KEY.set(context, modules = new THashSet<JpsModule>());
+          }
+          modules.add(module);
+        }
+      }
       return true;
     }
     return false;

From d6d73eeb2c9397207c88a92e98aa4d433bf1932b Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Tue, 26 Feb 2013 20:06:41 +0400
Subject: [PATCH 215/354] IDEA-101910 Idea connecting to remote maven
 repository in offline-mode if maven3 is used.

---
 .../jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java   | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java
index 4eda3c003754..d0dbbb8b19e3 100644
--- a/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java
+++ b/plugins/maven/maven3-server-impl/src/org/jetbrains/idea/maven/server/Maven3ServerEmbedderImpl.java
@@ -191,6 +191,8 @@ public class Maven3ServerEmbedderImpl extends MavenRemoteObject implements Maven
       Maven3ServerGlobals.getLogger().info(e);
     }
 
+    result.setOffline(settings.isOffline());
+
     if (settings.getLocalRepository() != null) {
       result.setLocalRepository(settings.getLocalRepository().getPath());
     }

From 9b845a666cfd0eb2727c0977604cd65c9833fec6 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 26 Feb 2013 15:45:18 +0100
Subject: [PATCH 216/354] add logging for create class fix (IDEA-100743)

---
 .../daemon/quickFix/CreateClassOrPackageFix.java   | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/CreateClassOrPackageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/CreateClassOrPackageFix.java
index 873631e57e2f..735520aa44ce 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/CreateClassOrPackageFix.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/quickFix/CreateClassOrPackageFix.java
@@ -23,6 +23,7 @@ import com.intellij.ide.util.DirectoryChooserUtil;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
@@ -43,6 +44,7 @@ import java.util.*;
  * @author peter
  */
 public class CreateClassOrPackageFix extends LocalQuickFixAndIntentionActionOnPsiElement {
+  private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.daemon.quickFix.CreateClassOrPackageFix");
   private final List<PsiDirectory> myWritableDirectoryList;
   private final String myPresentation;
 
@@ -233,9 +235,15 @@ public class CreateClassOrPackageFix extends LocalQuickFixAndIntentionActionOnPs
   public static List<PsiDirectory> getWritableDirectoryListDefault(@Nullable final PsiPackage context,
                                                                    final GlobalSearchScope scope,
                                                                    final PsiManager psiManager) {
+    if (LOG.isDebugEnabled()) {
+      LOG.debug("Getting writable directory list for package '" + (context == null ? null : context.getQualifiedName()) + "', scope=" + scope);
+    }
     final List<PsiDirectory> writableDirectoryList = new ArrayList<PsiDirectory>();
     if (context != null) {
       for (PsiDirectory directory : context.getDirectories()) {
+        if (LOG.isDebugEnabled()) {
+          LOG.debug("Package directory: " + directory);
+        }
         if (directory.isWritable() && scope.contains(directory.getVirtualFile())) {
           writableDirectoryList.add(directory);
         }
@@ -244,11 +252,17 @@ public class CreateClassOrPackageFix extends LocalQuickFixAndIntentionActionOnPs
     else {
       for (VirtualFile root : ProjectRootManager.getInstance(psiManager.getProject()).getContentSourceRoots()) {
         PsiDirectory directory = psiManager.findDirectory(root);
+        if (LOG.isDebugEnabled()) {
+          LOG.debug("Root: " + root + ", directory: " + directory);
+        }
         if (directory != null && directory.isWritable() && scope.contains(directory.getVirtualFile())) {
           writableDirectoryList.add(directory);
         }
       }
     }
+    if (LOG.isDebugEnabled()) {
+      LOG.debug("Result " + writableDirectoryList);
+    }
     return writableDirectoryList;
   }
 }

From a09c7d43c34c153369d2841d62ad6da61114b7fd Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 26 Feb 2013 16:08:15 +0100
Subject: [PATCH 217/354] IDEA-101789 Java: Strange completion variant

---
 .../completion/JavaChainLookupElement.java            | 10 +++-------
 .../completion/JavaPsiClassReferenceElement.java      |  6 +++++-
 .../codeInsight/completion/JavaAutoPopupTest.groovy   | 11 +++++++++--
 3 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
index 6d0b45fff5c4..6a47ad3e1ea4 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
@@ -15,16 +15,12 @@
  */
 package com.intellij.codeInsight.completion;
 
-import com.intellij.codeInsight.lookup.LookupElement;
-import com.intellij.codeInsight.lookup.LookupElementDecorator;
-import com.intellij.codeInsight.lookup.LookupElementPresentation;
-import com.intellij.codeInsight.lookup.TypedLookupItem;
+import com.intellij.codeInsight.lookup.*;
 import com.intellij.diagnostic.LogMessageEx;
 import com.intellij.diagnostic.errordialog.Attachment;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.util.ClassConditionKey;
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
@@ -97,8 +93,8 @@ public class JavaChainLookupElement extends LookupElementDecorator<LookupElement
     final String qualifierText = myQualifier.as(CastingLookupElementDecorator.CLASS_CONDITION_KEY) != null ? "(" + name + ")" : name;
     presentation.setItemText(qualifierText + "." + presentation.getItemText());
 
-    if (getQualifierObject() instanceof PsiClass) {
-      presentation.setTailText(StringUtil.notNullize(presentation.getTailText()) + qualifierPresentation.getTailText());
+    if (myQualifier instanceof LookupItem && getQualifierObject() instanceof PsiClass) {
+      presentation.setTailText(JavaPsiClassReferenceElement.getLocationString((LookupItem)myQualifier));
     }
   }
 
diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java
index 349cb7b47890..c1bfeda87531 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaPsiClassReferenceElement.java
@@ -152,7 +152,7 @@ public class JavaPsiClassReferenceElement extends LookupItem<Object> {
     presentation.setStrikeout(strikeout);
     presentation.setItemTextBold(bold);
 
-    String tailText = StringUtil.notNullize((String) item.getAttribute(LookupItem.TAIL_TEXT_ATTR));
+    String tailText = getLocationString(item);
     PsiSubstitutor substitutor = (PsiSubstitutor)item.getAttribute(LookupItem.SUBSTITUTOR);
 
     if (item instanceof PsiTypeLookupItem) {
@@ -173,6 +173,10 @@ public class JavaPsiClassReferenceElement extends LookupItem<Object> {
     presentation.setTailText(tailText, true);
   }
 
+  public static String getLocationString(LookupItem item) {
+    return StringUtil.notNullize((String)item.getAttribute(LookupItem.TAIL_TEXT_ATTR));
+  }
+
   private static String getName(final PsiClass psiClass, final LookupItem<?> item, boolean diamond) {
     if (item instanceof JavaPsiClassReferenceElement) {
       String forced = ((JavaPsiClassReferenceElement)item).getForcedPresentableName();
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy
index 79524d773600..0ab69b4eaeed 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/JavaAutoPopupTest.groovy
@@ -19,6 +19,7 @@ import com.intellij.codeInsight.TargetElementUtil
 import com.intellij.codeInsight.completion.impl.CompletionServiceImpl
 import com.intellij.codeInsight.editorActions.CompletionAutoPopupHandler
 import com.intellij.codeInsight.lookup.Lookup
+import com.intellij.codeInsight.lookup.LookupElementPresentation
 import com.intellij.codeInsight.lookup.LookupManager
 import com.intellij.codeInsight.lookup.impl.LookupImpl
 import com.intellij.codeInsight.template.TemplateManager
@@ -1195,11 +1196,17 @@ class Foo extends Abcdefg <caret>'''
   }
 
   public void testAmbiguousClassQualifier() {
-    myFixture.addClass("package foo; public class Util { public static void foo() {} }")
+    myFixture.addClass("package foo; public class Util<T> { public static void foo() {}; public static final int CONSTANT = 2; }")
     myFixture.addClass("package bar; public class Util { public static void bar() {} }")
     myFixture.configureByText 'a.java', 'class Foo {{ <caret> }}'
     type 'Util.'
-    assert myFixture.lookupElementStrings == ['Util.bar', 'Util.foo']
+    assert myFixture.lookupElementStrings == ['Util.bar', 'Util.CONSTANT', 'Util.foo']
+
+    def p = LookupElementPresentation.renderElement(myFixture.lookupElements[1])
+    assert p.itemText == 'Util.CONSTANT'
+    assert p.tailText == ' (foo)'
+    assert p.typeText == 'int'
+
     type 'fo\n'
     myFixture.checkResult '''import foo.Util;
 

From cb68737c83146db5b4a926b064d3c06252e32d80 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 26 Feb 2013 16:13:13 +0100
Subject: [PATCH 218/354] more diagnostics for failed reparse in IDEA-101709

---
 .../src/com/intellij/psi/SingleRootFileViewProvider.java  | 8 ++++++--
 .../intellij/psi/impl/source/text/BlockSupportImpl.java   | 5 +++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/platform/core-impl/src/com/intellij/psi/SingleRootFileViewProvider.java b/platform/core-impl/src/com/intellij/psi/SingleRootFileViewProvider.java
index d91811b2a6f3..3e76a9fb60ca 100644
--- a/platform/core-impl/src/com/intellij/psi/SingleRootFileViewProvider.java
+++ b/platform/core-impl/src/com/intellij/psi/SingleRootFileViewProvider.java
@@ -34,9 +34,8 @@ import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.UserDataHolderBase;
 import com.intellij.openapi.vfs.NonPhysicalFileSystem;
-import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.PersistentFSConstants;
-import com.intellij.psi.impl.PsiFileEx;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.impl.PsiManagerEx;
 import com.intellij.psi.impl.PsiManagerImpl;
 import com.intellij.psi.impl.file.PsiBinaryFileImpl;
@@ -471,6 +470,11 @@ public class SingleRootFileViewProvider extends UserDataHolderBase implements Fi
     myContent = content;
   }
 
+  @Override
+  public String toString() {
+    return getClass().getSimpleName() + "{myVirtualFile=" + myVirtualFile + '}';
+  }
+
   private interface Content {
     CharSequence getText();
 
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java b/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
index f2673843b5b6..c867da4dbc7b 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
@@ -179,7 +179,8 @@ public class BlockSupportImpl extends BlockSupport {
       FileViewProvider viewProvider = fileImpl.getViewProvider();
       viewProvider.getLanguages();
       FileType fileType = viewProvider.getVirtualFile().getFileType();
-      final LightVirtualFile lightFile = new LightVirtualFile(fileImpl.getName(), fileType, newFileText, viewProvider.getVirtualFile().getCharset(),
+      String fileName = fileImpl.getName();
+      final LightVirtualFile lightFile = new LightVirtualFile(fileName, fileType, newFileText, viewProvider.getVirtualFile().getCharset(),
                                                               fileImpl.getViewProvider().getModificationStamp());
       lightFile.setOriginalFile(viewProvider.getVirtualFile());
 
@@ -191,7 +192,7 @@ public class BlockSupportImpl extends BlockSupport {
 
       if (newFile == null) {
         throw new RuntimeException("View provider " + viewProvider + " refused to parse text with " + language +
-                  "; base: " + viewProvider.getBaseLanguage() + "; copy: " + copy.getBaseLanguage() + "; fileType: " + fileType);
+                  "; base: " + viewProvider.getBaseLanguage() + "; copy: " + copy.getBaseLanguage() + "; fileType: " + fileType + "; file name=" + fileName);
       }
 
       newFile.setOriginalFile(fileImpl);

From fa438eb3d72cf07d50e2b617f3ad8cb015363459 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 26 Feb 2013 17:13:41 +0100
Subject: [PATCH 219/354] IDEA-101570 Auto-Completing 'try' and 'finally'
 keywords does not honor next line brace placement

---
 .../com/intellij/codeInsight/TailTypes.java   | 22 ++---------
 .../completion/simple/BracesTailType.java     | 37 +++++++++++++++----
 .../completion/normal/BraceOnNextLine.java    |  5 +++
 .../normal/BraceOnNextLine_after.java         |  8 ++++
 .../completion/normal/DoForceBraces.java      |  5 +++
 .../normal/DoForceBraces_after.java           |  7 ++++
 .../completion/NormalCompletionTest.groovy    | 10 +++++
 7 files changed, 68 insertions(+), 26 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine.java
 create mode 100644 java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine_after.java
 create mode 100644 java/java-tests/testData/codeInsight/completion/normal/DoForceBraces.java
 create mode 100644 java/java-tests/testData/codeInsight/completion/normal/DoForceBraces_after.java

diff --git a/java/java-impl/src/com/intellij/codeInsight/TailTypes.java b/java/java-impl/src/com/intellij/codeInsight/TailTypes.java
index 43def9006a28..923dd8213019 100644
--- a/java/java-impl/src/com/intellij/codeInsight/TailTypes.java
+++ b/java/java-impl/src/com/intellij/codeInsight/TailTypes.java
@@ -118,24 +118,10 @@ public class TailTypes {
       return styleSettings.SPACE_WITHIN_IF_PARENTHESES;
     }
   };
-  public static final TailType FINALLY_LBRACE = new BracesTailType() {
-    @Override
-    protected boolean isSpaceBeforeLBrace(final CommonCodeStyleSettings styleSettings, final Editor editor, final int tailOffset) {
-      return styleSettings.SPACE_BEFORE_FINALLY_LBRACE;
-    }
-  };
-  public static final TailType TRY_LBRACE = new BracesTailType() {
-    @Override
-    protected boolean isSpaceBeforeLBrace(CommonCodeStyleSettings styleSettings, Editor editor, int tailOffset) {
-      return styleSettings.SPACE_BEFORE_TRY_LBRACE;
-    }
-  };
-  public static final TailType DO_LBRACE = new BracesTailType() {
-    @Override
-    protected boolean isSpaceBeforeLBrace(CommonCodeStyleSettings styleSettings, Editor editor, int tailOffset) {
-      return styleSettings.SPACE_BEFORE_DO_LBRACE;
-    }
-  };
+  private static final TailType BRACES = new BracesTailType();
+  public static final TailType FINALLY_LBRACE = BRACES;
+  public static final TailType TRY_LBRACE = BRACES;
+  public static final TailType DO_LBRACE = BRACES;
 
 
 
diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/simple/BracesTailType.java b/java/java-impl/src/com/intellij/codeInsight/completion/simple/BracesTailType.java
index 485836e48eb4..8e8703a58c4a 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/simple/BracesTailType.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/simple/BracesTailType.java
@@ -23,22 +23,31 @@ import com.intellij.ide.DataManager;
 import com.intellij.openapi.actionSystem.IdeActions;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.actionSystem.EditorActionManager;
-import com.intellij.psi.codeStyle.CommonCodeStyleSettings;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiDocumentManager;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.codeStyle.CodeStyleManager;
+import com.intellij.util.text.CharArrayUtil;
 
 /**
  * @author peter
  */
-public abstract class BracesTailType extends TailType {
-
-  protected abstract boolean isSpaceBeforeLBrace(CommonCodeStyleSettings styleSettings, Editor editor, final int tailOffset);
+public class BracesTailType extends TailType {
 
   @Override
   public int processTail(final Editor editor, int tailOffset) {
-    final CommonCodeStyleSettings styleSettings = getLocalCodeStyleSettings(editor, tailOffset);
-    if (isSpaceBeforeLBrace(styleSettings, editor, tailOffset)) {
-      tailOffset = insertChar(editor, tailOffset, ' ');
+    int startOffset = tailOffset;
+
+    CharSequence seq = editor.getDocument().getCharsSequence();
+    int nextNonWs = CharArrayUtil.shiftForward(seq, tailOffset, " \t");
+    if (nextNonWs < seq.length() && seq.charAt(nextNonWs) == '{') {
+      tailOffset = nextNonWs + 1;
+    } else {
+      tailOffset = insertChar(editor, startOffset, '{');
     }
-    tailOffset = insertChar(editor, tailOffset, '{');
+
+    tailOffset = reformatBrace(editor, tailOffset, startOffset);
+
     if (EnterAfterUnmatchedBraceHandler.isAfterUnmatchedLBrace(editor, tailOffset, getFileType(editor))) {
       new EnterHandler(EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_ENTER))
         .executeWriteAction(editor, DataManager.getInstance().getDataContext(editor.getContentComponent()));
@@ -47,4 +56,16 @@ public abstract class BracesTailType extends TailType {
     return tailOffset;
   }
 
+  private static int reformatBrace(Editor editor, int tailOffset, int startOffset) {
+    Project project = editor.getProject();
+    if (project != null) {
+      PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
+      if (psiFile != null) {
+        editor.getCaretModel().moveToOffset(tailOffset);
+        CodeStyleManager.getInstance(project).reformatText(psiFile, startOffset, tailOffset);
+        tailOffset = editor.getCaretModel().getOffset();
+      }
+    }
+    return tailOffset;
+  }
 }
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine.java b/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine.java
new file mode 100644
index 000000000000..021e46af66a4
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine.java
@@ -0,0 +1,5 @@
+class Foo {
+  {
+    try<caret>
+  }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine_after.java b/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine_after.java
new file mode 100644
index 000000000000..41f424d45562
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/completion/normal/BraceOnNextLine_after.java
@@ -0,0 +1,8 @@
+class Foo {
+  {
+    try
+    {
+        <caret>
+    }
+  }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces.java b/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces.java
new file mode 100644
index 000000000000..acd73c409865
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces.java
@@ -0,0 +1,5 @@
+class Foo {
+  {
+    do<caret>
+  }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces_after.java b/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces_after.java
new file mode 100644
index 000000000000..2b244ee14671
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/completion/normal/DoForceBraces_after.java
@@ -0,0 +1,7 @@
+class Foo {
+  {
+    do {
+        <caret>
+    }
+  }
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionTest.groovy
index 0c7e3f1ce4bf..87fe1ab17ee1 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/NormalCompletionTest.groovy
@@ -1331,5 +1331,15 @@ class XInternalError {}
     checkResult()
   }
 
+  public void testBraceOnNextLine() {
+    codeStyleSettings.BRACE_STYLE = CommonCodeStyleSettings.NEXT_LINE
+    doTest()
+  }
+
+  public void testDoForceBraces() {
+    codeStyleSettings.DOWHILE_BRACE_FORCE = CommonCodeStyleSettings.FORCE_BRACES_ALWAYS
+    doTest('\n')
+  }
+
 
 }

From 04e2ff859f73e56cc13d176c4d0733075681418f Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Tue, 26 Feb 2013 20:36:40 +0400
Subject: [PATCH 220/354] EA-43767 - IAE: IntentionActionMetaData.retrieveURLs

---
 .../intention/impl/config/IntentionActionMetaData.java | 10 +++++++---
 .../QuickEditAction/after.java.template                | 10 ----------
 .../QuickEditAction/after.txt.template                 |  3 +++
 .../QuickEditAction/before.java.template               | 10 ----------
 .../QuickEditAction/before.txt.template                |  3 +++
 .../EditInjectionSettingsAction/after.java.template    | 10 ----------
 .../EditInjectionSettingsAction/after.txt.template     |  3 +++
 .../EditInjectionSettingsAction/before.java.template   | 10 ----------
 .../EditInjectionSettingsAction/before.txt.template    |  3 +++
 .../InjectLanguageAction/after.java.template           | 10 ----------
 .../InjectLanguageAction/after.txt.template            |  3 +++
 .../InjectLanguageAction/before.java.template          | 10 ----------
 .../InjectLanguageAction/before.txt.template           |  3 +++
 .../UnInjectLanguageAction/after.java.template         | 10 ----------
 .../UnInjectLanguageAction/after.txt.template          |  3 +++
 .../UnInjectLanguageAction/before.java.template        | 10 ----------
 .../UnInjectLanguageAction/before.txt.template         |  3 +++
 17 files changed, 31 insertions(+), 83 deletions(-)
 delete mode 100644 platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.java.template
 create mode 100644 platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.txt.template
 delete mode 100644 platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.java.template
 create mode 100644 platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.txt.template
 delete mode 100644 plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.java.template
 create mode 100644 plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.txt.template

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/intention/impl/config/IntentionActionMetaData.java b/platform/lang-impl/src/com/intellij/codeInsight/intention/impl/config/IntentionActionMetaData.java
index 3b9ef426e7b9..57795443c9c3 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/intention/impl/config/IntentionActionMetaData.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/intention/impl/config/IntentionActionMetaData.java
@@ -25,6 +25,8 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.PluginId;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.util.ArrayUtil;
+import com.intellij.util.ObjectUtils;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -33,6 +35,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
+import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -154,7 +157,8 @@ public final class IntentionActionMetaData {
       String[] children;
       Exception cause = null;
       try {
-        children = new File(descriptionDirectory.toURI()).list();
+        URI uri = descriptionDirectory.toURI();
+        children = uri.isOpaque()? null : ObjectUtils.notNull(new File(uri).list(), ArrayUtil.EMPTY_STRING_ARRAY);
       }
       catch (URISyntaxException e) {
         cause = e;
@@ -164,8 +168,8 @@ public final class IntentionActionMetaData {
         cause = e;
         children = null;
       }
-      LOG.error("URLs not found for prefix: '"+prefix+"', suffix: '"+suffix+"'; in directory: '"+descriptionDirectory+"'; directory contents: "+
-                (children == null ? null : Arrays.asList(children)), cause);
+      LOG.error("URLs not found for available file types and prefix: '"+prefix+"', suffix: '"+suffix+"';" +
+                " in directory: '"+descriptionDirectory+ "'" + (children == null? "" : "; directory contents: "+ Arrays.asList(children)), cause);
       return new TextDescriptor[0];
     }
     return urls.toArray(new TextDescriptor[urls.size()]);
diff --git a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.java.template b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.java.template
deleted file mode 100644
index 67fb495564cd..000000000000
--- a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("select * from some_table");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.txt.template b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/after.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.java.template b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.java.template
deleted file mode 100644
index f6ee718db163..000000000000
--- a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("<spot>select * from some_table</spot>");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.txt.template b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/platform/platform-resources-en/src/intentionDescriptions/QuickEditAction/before.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.java.template b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.java.template
deleted file mode 100644
index 67fb495564cd..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("select * from some_table");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.txt.template b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/after.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.java.template b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.java.template
deleted file mode 100644
index f6ee718db163..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("<spot>select * from some_table</spot>");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.txt.template b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/EditInjectionSettingsAction/before.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.java.template b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.java.template
deleted file mode 100644
index 67fb495564cd..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("select * from some_table");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.txt.template b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/after.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.java.template b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.java.template
deleted file mode 100644
index f6ee718db163..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("<spot>select * from some_table</spot>");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.txt.template b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/InjectLanguageAction/before.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.java.template b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.java.template
deleted file mode 100644
index 67fb495564cd..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("select * from some_table");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.txt.template b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/after.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...
diff --git a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.java.template b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.java.template
deleted file mode 100644
index f6ee718db163..000000000000
--- a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.java.template
+++ /dev/null
@@ -1,10 +0,0 @@
-import java.sql.*;
-
-public class Test {
-    public void runScript(Statement st) throws SQLException {
-        st.execute("create table some_table (id integer primary key)");
-        st.execute("insert into some_table values(1)");
-        st.execute("<spot>select * from some_table</spot>");
-        st.execute("drop table some_table");
-    }
-}
\ No newline at end of file
diff --git a/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.txt.template b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.txt.template
new file mode 100644
index 000000000000..c4b64e5069ac
--- /dev/null
+++ b/plugins/IntelliLang/src/intentionDescriptions/UnInjectLanguageAction/before.txt.template
@@ -0,0 +1,3 @@
+...
+        sqlStatement.execute("<spot>select * from some_table</spot>");
+...

From 48c2ac113b68f4887113574926aa2bb24ca9e23b Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Tue, 26 Feb 2013 21:24:35 +0400
Subject: [PATCH 221/354] IDEA-101547 Please add a clock in fullscreen mode!
 AffineTransform fix (mac os )

---
 .../com/intellij/openapi/wm/impl/status/ClockPanel.java  | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
index 0a6d89d813ca..7b9e4890e371 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -118,7 +118,14 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
       int h = getHeight() - 4;
       int w = h / 2;
       float thickness = h * .1F;
-      g.setTransform(new AffineTransform(1, 0, -thickness / h, 1, thickness * 3, thickness / 4));
+      AffineTransform transform = g.getTransform();
+      if (transform == null) {
+        transform = new AffineTransform(1, 0, -thickness / h, 1, thickness * 3, thickness / 4);
+      }
+      else {
+        transform.concatenate(new AffineTransform(1, 0, -thickness / h, 1, thickness * 3, thickness / 4));
+      }
+      g.setTransform(transform);
       g.setStroke(new BasicStroke(thickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
       g.setColor(UIManager.getColor("Label.foreground"));
       myCalendar.setTimeInMillis(System.currentTimeMillis());

From a68a88d01496ba9a68da8be74ef2c9096013063d Mon Sep 17 00:00:00 2001
From: Shaverdova Elena <eshaverdova@gmail.com>
Date: Tue, 26 Feb 2013 19:25:30 +0400
Subject: [PATCH 222/354] Make Remote Host colors IDE theme dependent, not
 editor theme dependent +review CR-PS-9 (cherry picked from commit c07d007)

---
 colorSchemes/src/colorSchemes/Darcula.xml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 98e661029565..91971bde70d8 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -33,7 +33,6 @@
     <option name="NOTIFICATION_BACKGROUND" value="5c5c42" />
     <option name="READONLY_FRAGMENT_BACKGROUND" value="" />
     <option name="RECURSIVE_CALL_ATTRIBUTES" value="574300" />
-    <option name="REMOTE_HOST_MAPPED_BACKGROUND_KEY" value="164716" />
     <option name="RIGHT_MARGIN_COLOR" value="4d4d4d" />
     <option name="SELECTED_INDENT_GUIDE" value="505050" />
     <option name="SELECTED_TEARLINE_COLOR" value="787878" />

From 23056b8d2050d50b5af0eb34f3ae631c8d3cf917 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 17:51:14 +0100
Subject: [PATCH 223/354] method refs: patch getClass return value in the same
 way it is done in PsiMethodCallExpression

---
 .../intellij/psi/PsiMethodReferenceUtil.java  | 21 ++++----
 .../com/intellij/psi/util/PsiTypesUtil.java   | 49 +++++++++++++++++++
 .../java/PsiMethodCallExpressionImpl.java     | 47 +++++-------------
 .../lambda/methodRef/AccessModifiers.java     |  2 +-
 .../lambda/methodRef/GetClassSpecifics.java   | 15 ++++++
 .../lambda/MethodRefHighlightingTest.java     |  4 ++
 6 files changed, 91 insertions(+), 47 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/GetClassSpecifics.java

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index 070d42f58664..df2e6bde5dd4 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -18,10 +18,7 @@ package com.intellij.psi;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.pom.java.LanguageLevel;
-import com.intellij.psi.util.InheritanceUtil;
-import com.intellij.psi.util.MethodSignature;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.TypeConversionUtil;
+import com.intellij.psi.util.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -79,12 +76,7 @@ public class PsiMethodReferenceUtil {
     PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
     final PsiExpression expression = methodReferenceExpression.getQualifierExpression();
     if (expression != null) {
-      final PsiType expressionType = expression.getType();
-      if (expressionType instanceof PsiArrayType) {
-        containingClass = JavaPsiFacade.getInstance(methodReferenceExpression.getProject())
-          .findClass(CommonClassNames.JAVA_LANG_OBJECT, methodReferenceExpression.getResolveScope());
-        return new QualifierResolveResult(containingClass, substitutor, false);
-      }
+      final PsiType expressionType = getExpandedType(expression.getType(), expression);
       PsiClassType.ClassResolveResult result = PsiUtil.resolveGenericsClassInType(expressionType);
       containingClass = result.getElement();
       if (containingClass != null) {
@@ -152,7 +144,14 @@ public class PsiMethodReferenceUtil {
         final MethodSignature signature2 = ((PsiMethod)resolve).getSignature(subst);
 
         final PsiType interfaceReturnType = LambdaUtil.getFunctionalInterfaceReturnType(left);
-        PsiType methodReturnType = subst.substitute(((PsiMethod)resolve).getReturnType());
+        
+        PsiType returnType = PsiTypesUtil.patchMethodGetClassReturnType(methodReferenceExpression, methodReferenceExpression,
+                                                                        (PsiMethod)resolve, null,
+                                                                        PsiUtil.getLanguageLevel(methodReferenceExpression));
+        if (returnType == null) {
+          returnType = ((PsiMethod)resolve).getReturnType();
+        }
+        PsiType methodReturnType = subst.substitute(returnType);
         if (interfaceReturnType != null && interfaceReturnType != PsiType.VOID) {
           if (methodReturnType == null) {
             methodReturnType = JavaPsiFacade.getElementFactory(methodReferenceExpression.getProject()).createType(((PsiMethod)resolve).getContainingClass(), subst);
diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java
index 1eb3ae340a0e..43890225a21c 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java
@@ -15,7 +15,13 @@
  */
 package com.intellij.psi.util;
 
+import com.intellij.lang.ASTNode;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Condition;
+import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.util.containers.HashMap;
 import gnu.trove.THashMap;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -47,6 +53,8 @@ public class PsiTypesUtil {
     ourBoxedTypes.put("char", CommonClassNames.JAVA_LANG_CHARACTER);
   }
 
+  @NonNls private static final String GET_CLASS_METHOD = "getClass";
+
   private PsiTypesUtil() { }
 
   public static String getDefaultValueOfType(PsiType type) {
@@ -135,4 +143,45 @@ public class PsiTypesUtil {
     }
     return null;
   }
+
+  public static PsiType patchMethodGetClassReturnType(@NotNull PsiExpression call,
+                                                      @NotNull PsiReferenceExpression methodExpression,
+                                                      @NotNull PsiMethod method,
+                                                      @Nullable Condition<IElementType> condition,
+                                                      @NotNull LanguageLevel languageLevel) {
+    //JLS3 15.8.2
+    if (languageLevel.isAtLeast(LanguageLevel.JDK_1_5) &&
+        GET_CLASS_METHOD.equals(method.getName()) &&
+        CommonClassNames.JAVA_LANG_OBJECT.equals(method.getContainingClass().getQualifiedName())) {
+      PsiExpression qualifier = methodExpression.getQualifierExpression();
+      PsiType qualifierType = null;
+      final Project project = call.getProject();
+      if (qualifier != null) {
+        qualifierType = TypeConversionUtil.erasure(qualifier.getType());
+      }
+      else if (condition != null) {
+        ASTNode parent = call.getNode().getTreeParent();
+        while (parent != null && condition.value(parent.getElementType())) {
+          parent = parent.getTreeParent();
+        }
+        if (parent != null) {
+          qualifierType = JavaPsiFacade.getInstance(project).getElementFactory().createType((PsiClass)parent.getPsi());
+        }
+      }
+      if (qualifierType != null) {
+        PsiClass javaLangClass = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_CLASS, call.getResolveScope());
+        if (javaLangClass != null && javaLangClass.getTypeParameters().length == 1) {
+          Map<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
+          map.put(javaLangClass.getTypeParameters()[0], PsiWildcardType.createExtends(call.getManager(), qualifierType));
+          PsiSubstitutor substitutor = JavaPsiFacade.getInstance(project).getElementFactory().createSubstitutor(map);
+          final PsiClassType classType = JavaPsiFacade.getInstance(project).getElementFactory()
+            .createType(javaLangClass, substitutor, languageLevel);
+          final PsiElement parent = call.getParent();
+          return parent instanceof PsiReferenceExpression && parent.getParent() instanceof PsiMethodCallExpression
+                 ? PsiUtil.captureToplevelWildcards(classType, methodExpression) : classType;
+        }
+      }
+    }
+    return null;
+  }
 }
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodCallExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodCallExpressionImpl.java
index 7f9e847d9d66..dc092a73346b 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodCallExpressionImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiMethodCallExpressionImpl.java
@@ -17,6 +17,7 @@ package com.intellij.psi.impl.source.tree.java;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Condition;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.DebugUtil;
@@ -27,19 +28,15 @@ import com.intellij.psi.impl.source.tree.ElementType;
 import com.intellij.psi.impl.source.tree.JavaElementType;
 import com.intellij.psi.tree.ChildRoleBase;
 import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.util.PsiTypesUtil;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.util.Function;
-import com.intellij.util.containers.HashMap;
-import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Map;
-
 public class PsiMethodCallExpressionImpl extends ExpressionPsiElement implements PsiMethodCallExpression {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiMethodCallExpressionImpl");
-  @NonNls private static final String GET_CLASS_METHOD = "getClass";
 
   public PsiMethodCallExpressionImpl() {
     super(JavaElementType.METHOD_CALL_EXPRESSION);
@@ -174,39 +171,19 @@ public class PsiMethodCallExpressionImpl extends ExpressionPsiElement implements
     private static PsiType getResultType(PsiExpression call, PsiReferenceExpression methodExpression, JavaResolveResult result) {
       final PsiMethod method = (PsiMethod)result.getElement();
       if (method == null) return null;
-      PsiManager manager = call.getManager();
 
       final LanguageLevel languageLevel = PsiUtil.getLanguageLevel(call);
       boolean is15OrHigher = languageLevel.compareTo(LanguageLevel.JDK_1_5) >= 0;
-      //JLS3 15.8.2
-      if (is15OrHigher &&
-          GET_CLASS_METHOD.equals(method.getName()) &&
-          CommonClassNames.JAVA_LANG_OBJECT.equals(method.getContainingClass().getQualifiedName())) {
-        PsiExpression qualifier = methodExpression.getQualifierExpression();
-        PsiType qualifierType = null;
-        if (qualifier != null) {
-          qualifierType = TypeConversionUtil.erasure(qualifier.getType());
-        }
-        else {
-          ASTNode parent = call.getNode().getTreeParent();
-          while (parent != null && parent.getElementType() != JavaElementType.CLASS) parent = parent.getTreeParent();
-          if (parent != null) {
-            qualifierType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType((PsiClass)parent.getPsi());
-          }
-        }
-        if (qualifierType != null) {
-          PsiClass javaLangClass = JavaPsiFacade.getInstance(manager.getProject()).findClass("java.lang.Class", call.getResolveScope());
-          if (javaLangClass != null && javaLangClass.getTypeParameters().length == 1) {
-            Map<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
-            map.put(javaLangClass.getTypeParameters()[0], PsiWildcardType.createExtends(manager, qualifierType));
-            PsiSubstitutor substitutor = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createSubstitutor(map);
-            final PsiClassType classType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory()
-              .createType(javaLangClass, substitutor, languageLevel);
-            final PsiElement parent = call.getParent();
-            return parent instanceof PsiReferenceExpression && parent.getParent() instanceof PsiMethodCallExpression 
-                   ? PsiUtil.captureToplevelWildcards(classType, methodExpression) : classType;
-          }
-        }
+      final PsiType getClassReturnType = PsiTypesUtil.patchMethodGetClassReturnType(call, methodExpression, method,
+                                                                                    new Condition<IElementType>() {
+                                                                                      @Override
+                                                                                      public boolean value(IElementType type) {
+                                                                                        return type != JavaElementType.CLASS;
+                                                                                      }
+                                                                                    }, languageLevel);
+
+      if (getClassReturnType != null) {
+        return getClassReturnType;
       }
 
       PsiType ret = method.getReturnType();
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
index bd61f39024cb..ba449709ccbd 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AccessModifiers.java
@@ -69,7 +69,7 @@ class MyTest1 {
         <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest1.I3'">I3 c3 = arr::clone;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest1.I4'">I4 c5 = arr::clone;</error>
 
-        <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest1.I5'">I5 c4 = this::getClass;</error>
+        I5 c4 = this::getClass;
         <error descr="Incompatible types. Found: '<method reference>', required: 'MyTest1.I6'">I6 c6 = this::getClass;</error>
     }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/GetClassSpecifics.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/GetClassSpecifics.java
new file mode 100644
index 000000000000..6c5a26f6a87f
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/GetClassSpecifics.java
@@ -0,0 +1,15 @@
+import java.util.List;
+class GetClassTest {
+    interface GetCl {
+        Class<? extends List> _();
+    }
+
+    interface GetClReturnTypeProblems {
+        Class<List<String>> _();
+    }
+
+    void test(int[] iarr, List<String> ls) {
+        GetCl c4 = ls::getClass;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'GetClassTest.GetClReturnTypeProblems'">GetClReturnTypeProblems c5 = ls::getClass;</error>
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index 526c855784b6..c78f43b0c57f 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -196,6 +196,10 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testGetClassSpecifics() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From 7333331a42daecb58eaf617dbb2a226aef96c4c3 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 18:24:55 +0100
Subject: [PATCH 224/354] method refs: decline constructor refs on array ref
 with inapplicable substitutor

---
 .../src/com/intellij/psi/PsiMethodReferenceUtil.java      | 7 +++++++
 .../lambda/methodRef/RefOnArrayDeclaration.java           | 8 +++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index df2e6bde5dd4..ee4db06ad59a 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -163,6 +163,13 @@ public class PsiMethodReferenceUtil {
         final PsiType interfaceReturnType = LambdaUtil.getFunctionalInterfaceReturnType(left);
         if (interfaceReturnType != null) {
           if (interfaceReturnType == PsiType.VOID) return true;
+          if (onArrayType(((PsiClass)resolve), method.getSignature(PsiSubstitutor.EMPTY))) {
+            final PsiTypeParameter[] parameters = ((PsiClass)resolve).getTypeParameters();
+            if (parameters.length == 1) {
+              final PsiType arrayComponentType = result.getSubstitutor().substitute(parameters[0]);
+              return arrayComponentType != null && TypeConversionUtil.isAssignable(interfaceReturnType, arrayComponentType.createArrayType(), true);
+            }
+          }
           final PsiClassType classType = JavaPsiFacade.getElementFactory(methodReferenceExpression.getProject()).createType((PsiClass)resolve, result.getSubstitutor());
           if (TypeConversionUtil.isAssignable(interfaceReturnType, classType, !((PsiClass)resolve).hasTypeParameters())) {
             final PsiParameter[] parameters = method.getParameterList().getParameters();
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
index c4e45cec4c0c..ece30097b5a1 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
@@ -21,7 +21,9 @@ class OnArrayTest {
         String _(T[] ta);
     }
 
-
+    interface ArrayReturnType<T> {
+        T make(int size);
+    }
 
     public static void main(String[] args) {
         Cln s =  int[]::clone;
@@ -29,5 +31,9 @@ class OnArrayTest {
         <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.I'">I i = int[]::new;</error>
         <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.Len<java.lang.String>'">Len<String> strLen = String[]::length;</error>
         ToStr<Integer> toStr = Integer[]::toString;
+
+        ArrayReturnType<String[]> a1 = String[]::new;
+        ArrayReturnType<String[][]> a2 = String[][]::new;
+        <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.ArrayReturnType<java.lang.String[]>'">ArrayReturnType<String[]> a3 = int[]::new;</error>
     }
 }

From 2d1f7206ceac42b27619135169225565c0517ac2 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 19:20:36 +0100
Subject: [PATCH 225/354] separate icon move changes to another change list

---
 .../vcs/changes/actions/MoveChangesToAnotherListAction.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/actions/MoveChangesToAnotherListAction.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/actions/MoveChangesToAnotherListAction.java
index 75ff4cebe540..4c6385dae85e 100644
--- a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/actions/MoveChangesToAnotherListAction.java
+++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/actions/MoveChangesToAnotherListAction.java
@@ -45,7 +45,7 @@ public class MoveChangesToAnotherListAction extends AnAction implements DumbAwar
   public MoveChangesToAnotherListAction() {
     super(ActionsBundle.actionText("ChangesView.Move"),
           ActionsBundle.actionDescription("ChangesView.Move"),
-          AllIcons.Actions.FileStatus);
+          AllIcons.Actions.MoveToAnotherChangelist);
   }
 
   public void update(AnActionEvent e) {

From 2ceabcf7ba2721877f2c565eb14bec2118518b76 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 19:48:05 +0100
Subject: [PATCH 226/354] method refs: super::abstract method

---
 .../impl/analysis/HighlightVisitorImpl.java   | 14 ++++++++++++-
 .../lambda/methodRef/AbstractMethod.java      | 20 +++++++++++++++++++
 .../lambda/MethodRefHighlightingTest.java     |  4 ++++
 3 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AbstractMethod.java

diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
index 914ff060280f..7d97295b8bab 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
@@ -1040,7 +1040,8 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
     if (myRefCountHolder != null) {
       myRefCountHolder.registerReference(expression, result);
     }
-    if (result.getElement() != null && !result.isAccessible()) {
+    final PsiElement method = result.getElement();
+    if (method != null && !result.isAccessible()) {
       final String accessProblem = HighlightUtil.buildProblemWithAccessDescription(expression, result);
       HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(accessProblem).create();
       myHolder.add(info);
@@ -1075,6 +1076,17 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
     if (!myHolder.hasErrorResults()) {
       myHolder.add(HighlightUtil.checkUnhandledExceptions(expression, expression.getTextRange()));
     }
+    if (!myHolder.hasErrorResults()) {
+      if (method instanceof PsiMethod && ((PsiMethod)method).hasModifierProperty(PsiModifier.ABSTRACT)) {
+        final PsiElement qualifier = expression.getQualifier();
+        if (qualifier instanceof PsiSuperExpression) {
+          myHolder.add(HighlightInfo
+                         .newHighlightInfo(HighlightInfoType.ERROR)
+                         .range(expression.getReferenceNameElement())
+                         .descriptionAndTooltip("Abstract method '" + ((PsiMethod)method).getName() + "' cannot be accessed directly").create());
+        }
+      }
+    }
   }
 
   @Override
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AbstractMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AbstractMethod.java
new file mode 100644
index 000000000000..ace561a0e02c
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/AbstractMethod.java
@@ -0,0 +1,20 @@
+class Test {
+    interface I {
+        int _();
+    }
+
+    static abstract class Parent {
+        abstract int foo() ;
+    }
+
+    static abstract class Child extends Parent {
+        abstract int foo() ;
+        void test() {
+            I s = super::<error descr="Abstract method 'foo' cannot be accessed directly">foo</error>;
+            I s1 = this::foo;
+
+            Parent sup = null;
+            I s2 = sup::foo;
+        }
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index c78f43b0c57f..c9db5801746a 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -200,6 +200,10 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testAbstractMethod() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From f247ebba0202e282dc7be62b5241ec49f3e19a80 Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Tue, 26 Feb 2013 23:20:57 +0400
Subject: [PATCH 227/354] Fix emmet wrapping

---
 .../intellij/codeInsight/template/emmet/XmlEmmetParser.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
index 4b770f103bd1..b8c5367e8fdf 100644
--- a/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
+++ b/xml/impl/src/com/intellij/codeInsight/template/emmet/XmlEmmetParser.java
@@ -26,6 +26,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.xml.XmlTag;
+import com.intellij.psi.xml.XmlTokenType;
 import com.intellij.util.containers.Stack;
 import com.intellij.xml.util.HtmlUtil;
 import org.jetbrains.annotations.NonNls;
@@ -79,7 +80,7 @@ public class XmlEmmetParser extends EmmetParser {
     super(tokens, callback, generator);
     PsiElement context = callback.getContext();
     XmlTag parentTag = PsiTreeUtil.getParentOfType(context, XmlTag.class);
-    if (surroundWithTemplate && parentTag != null) {
+    if (surroundWithTemplate && parentTag != null && context.getNode().getElementType() == XmlTokenType.XML_START_TAG_START) {
       parentTag = PsiTreeUtil.getParentOfType(parentTag, XmlTag.class);
     }
     if (parentTag != null) {

From e48f61bf4d390187826ba385782f087674e57050 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 20:22:48 +0100
Subject: [PATCH 228/354] method refs: test data to check
 enum/interface/annotation not accepted; isAcceptable checks on Array types

---
 .../intellij/psi/PsiMethodReferenceUtil.java  | 12 ++++----
 .../lambda/methodRef/MethodRefAcceptance.java | 29 +++++++++++++++++++
 .../methodRef/RefOnArrayDeclaration.java      |  8 +++++
 .../lambda/MethodRefHighlightingTest.java     |  4 +++
 4 files changed, 48 insertions(+), 5 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefAcceptance.java

diff --git a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
index ee4db06ad59a..1d0b2d750304 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiMethodReferenceUtil.java
@@ -163,16 +163,18 @@ public class PsiMethodReferenceUtil {
         final PsiType interfaceReturnType = LambdaUtil.getFunctionalInterfaceReturnType(left);
         if (interfaceReturnType != null) {
           if (interfaceReturnType == PsiType.VOID) return true;
-          if (onArrayType(((PsiClass)resolve), method.getSignature(PsiSubstitutor.EMPTY))) {
-            final PsiTypeParameter[] parameters = ((PsiClass)resolve).getTypeParameters();
-            if (parameters.length == 1) {
-              final PsiType arrayComponentType = result.getSubstitutor().substitute(parameters[0]);
+          final PsiParameter[] parameters = method.getParameterList().getParameters();
+          if (resolve == JavaPsiFacade.getElementFactory(resolve.getProject()).getArrayClass(PsiUtil.getLanguageLevel(resolve))) {
+            if (parameters.length != 1 || parameters[0].getType() != PsiType.INT) return false;
+            final PsiTypeParameter[] typeParameters = ((PsiClass)resolve).getTypeParameters();
+            if (typeParameters.length == 1) {
+              final PsiType arrayComponentType = result.getSubstitutor().substitute(typeParameters[0]);
               return arrayComponentType != null && TypeConversionUtil.isAssignable(interfaceReturnType, arrayComponentType.createArrayType(), true);
             }
+            return false;
           }
           final PsiClassType classType = JavaPsiFacade.getElementFactory(methodReferenceExpression.getProject()).createType((PsiClass)resolve, result.getSubstitutor());
           if (TypeConversionUtil.isAssignable(interfaceReturnType, classType, !((PsiClass)resolve).hasTypeParameters())) {
-            final PsiParameter[] parameters = method.getParameterList().getParameters();
             if (parameters.length == 0) return true;
             if (parameters.length == 1) {
               if (isReceiverType(resolveResult.getSubstitutor().substitute(parameters[0].getType()), qualifierResolveResult.getContainingClass(), qualifierResolveResult.getSubstitutor())) return true;
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefAcceptance.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefAcceptance.java
new file mode 100644
index 000000000000..b7f3df71fe58
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodRefAcceptance.java
@@ -0,0 +1,29 @@
+class Test {
+    interface IFactory {
+        Object m();
+    }
+
+    @interface Anno {}
+
+    enum E {}
+
+    interface I {}
+
+    static class Foo<X> { }
+
+    void foo(IFactory cf) { }
+
+    void testAssign() {
+        <error descr="Incompatible types. Found: '<method reference>', required: 'Test.IFactory'">IFactory c1 = Anno::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'Test.IFactory'">IFactory c2 = E::new;</error>
+        <error descr="Incompatible types. Found: '<method reference>', required: 'Test.IFactory'">IFactory c3 = I::new;</error>
+        IFactory c4 = Foo<?>::new;
+        IFactory c5 = <error descr="Cannot find class 1">1</error>::new;
+
+        foo<error descr="'foo(Test.IFactory)' in 'Test' cannot be applied to '(<method reference>)'">(Anno::new)</error>;
+        foo<error descr="'foo(Test.IFactory)' in 'Test' cannot be applied to '(<method reference>)'">(E::new)</error>;
+        foo<error descr="'foo(Test.IFactory)' in 'Test' cannot be applied to '(<method reference>)'">(I::new)</error>;
+        foo(Foo<?>::new);
+        foo(<error descr="Cannot find class 1">1</error>::new);
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
index ece30097b5a1..3ed7e3ef5863 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RefOnArrayDeclaration.java
@@ -25,6 +25,11 @@ class OnArrayTest {
         T make(int size);
     }
 
+    static class Foo<X> { }
+    interface ObjectArrayReturnType {
+        Object make(int size);
+    }
+
     public static void main(String[] args) {
         Cln s =  int[]::clone;
         IA a =  int[]::new;
@@ -35,5 +40,8 @@ class OnArrayTest {
         ArrayReturnType<String[]> a1 = String[]::new;
         ArrayReturnType<String[][]> a2 = String[][]::new;
         <error descr="Incompatible types. Found: '<method reference>', required: 'OnArrayTest.ArrayReturnType<java.lang.String[]>'">ArrayReturnType<String[]> a3 = int[]::new;</error>
+        
+        ObjectArrayReturnType a4 = Foo<?>[]::new;
+        ObjectArrayReturnType a5 = Foo<? extends String>[]::new;
     }
 }
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index c9db5801746a..93c0f64da8f2 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -204,6 +204,10 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testMethodRefAcceptance() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From 9c40687a13fd2886d7ae40f42563735b53a77f85 Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Tue, 26 Feb 2013 23:50:48 +0400
Subject: [PATCH 229/354] EA-43941 - assert: PsiBuilderImpl.prepareLightTree:
 space prefix makes frame.offset=1

---
 .../src/com/intellij/lang/parser/GeneratedParserUtilBase.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/lang/parser/GeneratedParserUtilBase.java b/platform/lang-impl/src/com/intellij/lang/parser/GeneratedParserUtilBase.java
index 6b65d3d73d23..f772bce55153 100644
--- a/platform/lang-impl/src/com/intellij/lang/parser/GeneratedParserUtilBase.java
+++ b/platform/lang-impl/src/com/intellij/lang/parser/GeneratedParserUtilBase.java
@@ -322,7 +322,7 @@ public class GeneratedParserUtilBase {
         eatMoreFlagOnce ? builder_.getLatestDoneMarker() : null;
       PsiBuilder.Marker extensionMarker = null;
       IElementType extensionTokenType = null;
-      if (latestDoneMarker instanceof PsiBuilder.Marker && frame.offset == latestDoneMarker.getStartOffset()) {
+      if (latestDoneMarker instanceof PsiBuilder.Marker && frame.offset >= latestDoneMarker.getStartOffset()) {
         extensionMarker = ((PsiBuilder.Marker)latestDoneMarker).precede();
         extensionTokenType = latestDoneMarker.getTokenType();
         ((PsiBuilder.Marker)latestDoneMarker).drop();

From 4bf90bf26de3c0e1d6daaba057c7aa4c02bf336f Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 20:48:35 +0100
Subject: [PATCH 230/354] lambda: testdata

---
 ...laredTypeParameterBoundsAndUnboundedWildcard.java | 12 ++++++++++++
 .../daemon/lambda/LambdaHighlightingTest.java        |  4 ++++
 2 files changed, 16 insertions(+)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DeclaredTypeParameterBoundsAndUnboundedWildcard.java

diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DeclaredTypeParameterBoundsAndUnboundedWildcard.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DeclaredTypeParameterBoundsAndUnboundedWildcard.java
new file mode 100644
index 000000000000..4c56606e55ef
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DeclaredTypeParameterBoundsAndUnboundedWildcard.java
@@ -0,0 +1,12 @@
+class Test {
+    interface I<T extends Number> {
+        void _(T t);
+    }
+    
+    void foo(Object o) { }
+
+    void test() {
+        I<?> i1 = (x) -> {};
+        I<?> i2 = this :: foo;
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 0ecff16b3a0e..03973993d10a 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -232,6 +232,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testDeclaredTypeParameterBoundsAndUnboundedWildcard() throws Exception {
+    doTest();
+  }
+
   private void doTest() throws Exception {
     doTest(false);
   }

From 387e7070ff0f727e2733e1f1f3c08dd1f0f1f8b3 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Tue, 26 Feb 2013 21:18:14 +0100
Subject: [PATCH 231/354] javafx layout for CE fixed

---
 build/scripts/layouts.gant | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/build/scripts/layouts.gant b/build/scripts/layouts.gant
index 18e2cd39d914..611a3021245b 100644
--- a/build/scripts/layouts.gant
+++ b/build/scripts/layouts.gant
@@ -178,11 +178,13 @@ def layoutFull(String home, String targetDirectory, String patchedDescriptorDir
 
     layoutCommunityPlugins(home)
 
-    layoutPlugin("javaFX") {
-      dir("lib") {
-        jar("javaFX.jar") {
-          module("javaFX")
-          module("javaFX-CE")
+    dir("plugins") {
+      dir("javaFX") {
+        dir("lib") {
+          jar("javaFX.jar") {
+            module("javaFX")
+            module("javaFX-CE")
+          }
         }
       }
     }

From c7b284059040ca8d7592dfa685b562b2ddda0b79 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 20:46:52 +0100
Subject: [PATCH 232/354] Formatting

---
 .../com/intellij/psi/impl/cache/TypeInfo.java | 45 ++++++++++++-------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/cache/TypeInfo.java b/java/java-psi-impl/src/com/intellij/psi/impl/cache/TypeInfo.java
index c575fda495b7..0b4dc267bf66 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/cache/TypeInfo.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/cache/TypeInfo.java
@@ -91,20 +91,42 @@ public class TypeInfo {
   public final boolean isEllipsis;
   private final List<PsiAnnotationStub> myAnnotationStubs;
 
-  public TypeInfo(StringRef text, byte arrayCount, boolean ellipsis, @NotNull List<PsiAnnotationStub> annotationStubs) {
-    this.text = text;
-    this.arrayCount = arrayCount;
+  public TypeInfo(StringRef _text, byte _arrayCount, boolean ellipsis, @NotNull List<PsiAnnotationStub> annotationStubs) {
+    text = _text;
+    arrayCount = _arrayCount;
     isEllipsis = ellipsis;
     myAnnotationStubs = annotationStubs;
   }
 
   public TypeInfo(@NotNull TypeInfo typeInfo) {
-    this.text = typeInfo.text;
-    this.arrayCount = typeInfo.arrayCount;
+    text = typeInfo.text;
+    arrayCount = typeInfo.arrayCount;
     isEllipsis = typeInfo.isEllipsis;
     myAnnotationStubs = new SmartList<PsiAnnotationStub>(typeInfo.myAnnotationStubs);
   }
 
+  public void addAnnotation(PsiAnnotationStub annotation) {
+    myAnnotationStubs.add(annotation);
+  }
+
+  @NotNull
+  public String getShortTypeText() {
+    if (text == null) return "";
+    String name = PsiNameHelper.getShortClassName(text.getString());
+    if (arrayCount > 0) {
+      name += StringUtil.repeat("[]", arrayCount);
+    }
+    return name;
+  }
+
+  @Override
+  public String toString() {
+    String text = createTypeText(this);
+    return text != null ? text : "null";
+  }
+
+  /* factories and serialization */
+
   @NotNull
   public static TypeInfo createConstructorType() {
     return NULL;
@@ -162,7 +184,7 @@ public class TypeInfo {
   }
 
   @NotNull
-  public static TypeInfo fromString(String typeText, boolean isEllipsis) {
+  public static TypeInfo fromString(@NotNull String typeText, boolean isEllipsis) {
     assert !typeText.endsWith("...") : typeText;
 
     byte arrayCount = 0;
@@ -277,15 +299,4 @@ public class TypeInfo {
 
     return buf.toString();
   }
-
-  public void addAnnotation(PsiAnnotationStub annotation) {
-    myAnnotationStubs.add(annotation);
-  }
-
-  @NotNull
-  public String getShortTypeText() {
-    if (text == null) return "";
-    String name = PsiNameHelper.getShortClassName(text.getString());
-    return arrayCount > 0 ? name + StringUtil.repeat("[]", arrayCount) : name;
-  }
 }

From 34a18a4f96c4e88d30ddd34e69c2b0ac5d75c132 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Tue, 26 Feb 2013 21:21:55 +0100
Subject: [PATCH 233/354] IDEA-101854 (refresh cache reduced)

---
 .../vfs/newvfs/RefreshSessionImpl.java        |   2 +-
 .../vfs/newvfs/persistent/RefreshWorker.java  | 151 ++++++++----------
 2 files changed, 68 insertions(+), 85 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/RefreshSessionImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/RefreshSessionImpl.java
index 3a4485e661cc..d58cbb4b4e9e 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/RefreshSessionImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/RefreshSessionImpl.java
@@ -132,7 +132,7 @@ public class RefreshSessionImpl extends RefreshSession {
           nvf.markDirty();
         }
 
-        RefreshWorker worker = myWorker = new RefreshWorker(file, myIsRecursive);
+        RefreshWorker worker = myWorker = new RefreshWorker(nvf, myIsRecursive);
         worker.scan();
         List<VFileEvent> events = worker.getEvents();
         if (myEvents.addAll(events)) {
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/RefreshWorker.java b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/RefreshWorker.java
index 090156b090db..60e409956e88 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/RefreshWorker.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/newvfs/persistent/RefreshWorker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -17,6 +17,7 @@ package com.intellij.openapi.vfs.newvfs.persistent;
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileAttributes;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VfsUtil;
@@ -26,13 +27,14 @@ import com.intellij.openapi.vfs.newvfs.NewVirtualFileSystem;
 import com.intellij.openapi.vfs.newvfs.events.*;
 import com.intellij.openapi.vfs.newvfs.impl.FakeVirtualFile;
 import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
-import com.intellij.openapi.vfs.newvfs.impl.VirtualFileSystemEntry;
-import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.Queue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 import static com.intellij.openapi.diagnostic.LogUtil.debug;
 import static com.intellij.util.containers.ContainerUtil.newHashSet;
@@ -44,14 +46,18 @@ public class RefreshWorker {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vfs.newvfs.persistent.RefreshWorker");
 
   private final boolean myIsRecursive;
-  private final Queue<VirtualFile> myRefreshQueue = new Queue<VirtualFile>(100);
+  private final Queue<Pair<NewVirtualFile, FileAttributes>> myRefreshQueue = new Queue<Pair<NewVirtualFile, FileAttributes>>(100);
   private final List<VFileEvent> myEvents = new ArrayList<VFileEvent>();
   private volatile boolean myCancelled = false;
-  private final Map<String, FileAttributes> myFsCache = ContainerUtil.newTroveMap();
 
-  public RefreshWorker(final VirtualFile refreshRoot, final boolean isRecursive) {
+  public RefreshWorker(@NotNull NewVirtualFile refreshRoot, boolean isRecursive) {
     myIsRecursive = isRecursive;
-    myRefreshQueue.addLast(refreshRoot);
+    myRefreshQueue.addLast(Pair.create(refreshRoot, (FileAttributes)null));
+  }
+
+  @NotNull
+  public List<VFileEvent> getEvents() {
+    return myEvents;
   }
 
   public void cancel() {
@@ -59,43 +65,40 @@ public class RefreshWorker {
   }
 
   public void scan() {
-    final NewVirtualFile root = (NewVirtualFile)myRefreshQueue.peekFirst();
-    final boolean rootDirty = root.isDirty();
+    NewVirtualFile root = myRefreshQueue.pullFirst().first;
+    boolean rootDirty = root.isDirty();
     debug(LOG, "root=%s dirty=%b", root, rootDirty);
     if (!rootDirty) return;
-    final long t = System.currentTimeMillis();
 
     NewVirtualFileSystem fs = root.getFileSystem();
-    final FileAttributes rootAttributes = getAttributes(fs, root);
-
+    FileAttributes rootAttributes = fs.getAttributes(root);
     if (rootAttributes == null) {
       scheduleDeletion(root);
       root.markClean();
-      debug(LOG, "root=%s time=%d", root, System.currentTimeMillis() - t);
       return;
     }
-
     if (rootAttributes != null && rootAttributes.isDirectory()) {
       fs = PersistentFS.replaceWithNativeFS(fs);
     }
-
-    final PersistentFS persistence = PersistentFS.getInstance();
+    myRefreshQueue.addLast(Pair.create(root, rootAttributes));
+    PersistentFS persistence = PersistentFS.getInstance();
 
     main:
     while (!myRefreshQueue.isEmpty() && !myCancelled) {
-      final VirtualFileSystemEntry file = (VirtualFileSystemEntry)myRefreshQueue.pullFirst();
-      final boolean fileDirty = file.isDirty();
+      Pair<NewVirtualFile, FileAttributes> pair = myRefreshQueue.pullFirst();
+      NewVirtualFile file = pair.first;
+      boolean fileDirty = file.isDirty();
       debug(LOG, "file=%s dirty=%b", file, fileDirty);
       if (!fileDirty) continue;
 
-      final FileAttributes attributes = getAttributes(fs, file);
+      FileAttributes attributes = pair.second != null ? pair.second : fs.getAttributes(file);
       if (attributes == null) {
         scheduleDeletion(file);
         continue;
       }
 
       boolean checkFurther = true;
-      final VirtualFileSystemEntry parent = file.getParent();
+      NewVirtualFile parent = file.getParent();
       if (parent != null &&
           (checkAndScheduleAttributesChange(parent, file, attributes) ||
            checkAndScheduleSymLinkTargetChange(parent, file, attributes, fs))) {
@@ -103,14 +106,14 @@ public class RefreshWorker {
         checkFurther = false;
       }
       else if (file.isDirectory()) {
-        final VirtualDirectoryImpl dir = (VirtualDirectoryImpl)file;
-        final boolean fullSync = dir.allChildrenLoaded();
+        VirtualDirectoryImpl dir = (VirtualDirectoryImpl)file;
+        boolean fullSync = dir.allChildrenLoaded();
         if (fullSync) {
-          final Set<String> currentNames = newHashSet(persistence.list(file));
-          final Set<String> upToDateNames = newHashSet(VfsUtil.filterNames(fs.list(file)));
-          final Set<String> newNames = newHashSet(upToDateNames);
+          Set<String> currentNames = newHashSet(persistence.list(file));
+          Set<String> upToDateNames = newHashSet(VfsUtil.filterNames(fs.list(file)));
+          Set<String> newNames = newHashSet(upToDateNames);
           newNames.removeAll(currentNames);
-          final Set<String> deletedNames = newHashSet(currentNames);
+          Set<String> deletedNames = newHashSet(currentNames);
           deletedNames.removeAll(upToDateNames);
           debug(LOG, "current=%s +%s -%s", currentNames, newNames, deletedNames);
 
@@ -120,7 +123,7 @@ public class RefreshWorker {
 
           for (String name : newNames) {
             if (myCancelled) break main;
-            final FileAttributes childAttributes = getAttributes(fs, new FakeVirtualFile(file, name));
+            FileAttributes childAttributes = fs.getAttributes(new FakeVirtualFile(file, name));
             if (childAttributes != null) {
               scheduleCreation(file, name, childAttributes.isDirectory());
             }
@@ -132,7 +135,7 @@ public class RefreshWorker {
           for (VirtualFile child : file.getChildren()) {
             if (myCancelled) break main;
             if (!deletedNames.contains(child.getName())) {
-              final FileAttributes childAttributes = getAttributes(fs, child);
+              FileAttributes childAttributes = fs.getAttributes(child);
               if (childAttributes != null) {
                 checkAndScheduleChildRefresh(file, child, childAttributes);
               }
@@ -144,11 +147,11 @@ public class RefreshWorker {
           }
         }
         else {
-          final Collection<VirtualFile> cachedChildren = file.getCachedChildren();
+          Collection<VirtualFile> cachedChildren = file.getCachedChildren();
           debug(LOG, "cached=%s", cachedChildren);
           for (VirtualFile child : cachedChildren) {
             if (myCancelled) break main;
-            final FileAttributes childAttributes = getAttributes(fs, child);
+            FileAttributes childAttributes = fs.getAttributes(child);
             if (childAttributes != null) {
               checkAndScheduleChildRefresh(file, child, childAttributes);
             }
@@ -157,14 +160,14 @@ public class RefreshWorker {
             }
           }
 
-          final List<String> names = dir.getSuspiciousNames();
+          List<String> names = dir.getSuspiciousNames();
           debug(LOG, "suspicious=%s", names);
           for (String name : names) {
             if (myCancelled) break main;
             if (name.isEmpty()) continue;
 
-            final VirtualFile fake = new FakeVirtualFile(file, name);
-            final FileAttributes childAttributes = getAttributes(fs, fake);
+            VirtualFile fake = new FakeVirtualFile(file, name);
+            FileAttributes childAttributes = fs.getAttributes(fake);
             if (childAttributes != null) {
               scheduleCreation(file, name, childAttributes.isDirectory());
             }
@@ -172,10 +175,10 @@ public class RefreshWorker {
         }
       }
       else {
-        final long currentTimestamp = persistence.getTimeStamp(file);
-        final long upToDateTimestamp = attributes.lastModified;
-        final long currentLength = persistence.getLength(file);
-        final long upToDateLength = attributes.length;
+        long currentTimestamp = persistence.getTimeStamp(file);
+        long upToDateTimestamp = attributes.lastModified;
+        long currentLength = persistence.getLength(file);
+        long upToDateLength = attributes.length;
 
         if (currentTimestamp != upToDateTimestamp || currentLength != upToDateLength) {
           scheduleUpdateContent(file);
@@ -183,8 +186,8 @@ public class RefreshWorker {
       }
 
       if (checkFurther) {
-        final boolean currentWritable = persistence.isWritable(file);
-        final boolean upToDateWritable = attributes.isWritable();
+        boolean currentWritable = persistence.isWritable(file);
+        boolean upToDateWritable = attributes.isWritable();
 
         if (currentWritable != upToDateWritable) {
           scheduleWritableAttributeChange(file, currentWritable, upToDateWritable);
@@ -193,100 +196,80 @@ public class RefreshWorker {
 
       file.markClean();
     }
-
-    myFsCache.clear();
-    debug(LOG, "root=%s time=%d", root, System.currentTimeMillis() - t);
   }
 
-  @Nullable
-  private FileAttributes getAttributes(@NotNull NewVirtualFileSystem fs, @NotNull VirtualFile file) {
-    String path = file.getPath();
-    FileAttributes attributes = myFsCache.get(path);
-    if (attributes == null) {
-      attributes = fs.getAttributes(file);
-      myFsCache.put(path, attributes);
-    }
-    return attributes;
-  }
-
-  private void checkAndScheduleChildRefresh(@NotNull VirtualFileSystemEntry parent,
+  private void checkAndScheduleChildRefresh(@NotNull VirtualFile parent,
                                             @NotNull VirtualFile child,
                                             @NotNull FileAttributes childAttributes) {
     if (!checkAndScheduleAttributesChange(parent, child, childAttributes)) {
-      final boolean upToDateIsDirectory = childAttributes.isDirectory();
+      boolean upToDateIsDirectory = childAttributes.isDirectory();
       if (myIsRecursive || !upToDateIsDirectory) {
-        myRefreshQueue.addLast(child);
+        myRefreshQueue.addLast(Pair.create((NewVirtualFile)child, childAttributes));
       }
     }
   }
 
-  private boolean checkAndScheduleAttributesChange(@NotNull VirtualFileSystemEntry parent,
+  private boolean checkAndScheduleAttributesChange(@NotNull VirtualFile parent,
                                                    @NotNull VirtualFile child,
                                                    @NotNull FileAttributes childAttributes) {
-    final boolean currentIsDirectory = child.isDirectory();
-    final boolean currentIsSymlink = child.isSymLink();
-    final boolean currentIsSpecial = child.isSpecialFile();
-    final boolean upToDateIsDirectory = childAttributes.isDirectory();
-    final boolean upToDateIsSymlink = childAttributes.isSymLink();
-    final boolean upToDateIsSpecial = child.isSpecialFile();
+    boolean currentIsDirectory = child.isDirectory();
+    boolean currentIsSymlink = child.isSymLink();
+    boolean currentIsSpecial = child.isSpecialFile();
+    boolean upToDateIsDirectory = childAttributes.isDirectory();
+    boolean upToDateIsSymlink = childAttributes.isSymLink();
+    boolean upToDateIsSpecial = child.isSpecialFile();
 
-    if (currentIsDirectory != upToDateIsDirectory ||
-        currentIsSymlink != upToDateIsSymlink ||
-        currentIsSpecial != upToDateIsSpecial) {
+    if (currentIsDirectory != upToDateIsDirectory || currentIsSymlink != upToDateIsSymlink || currentIsSpecial != upToDateIsSpecial) {
       scheduleDeletion(child);
       scheduleReCreation(parent, child.getName(), upToDateIsDirectory);
       return true;
     }
-    else {
-      return false;
-    }
+
+    return false;
   }
 
-  private boolean checkAndScheduleSymLinkTargetChange(@NotNull VirtualFileSystemEntry parent,
+  private boolean checkAndScheduleSymLinkTargetChange(@NotNull VirtualFile parent,
                                                       @NotNull VirtualFile child,
                                                       @NotNull FileAttributes childAttributes,
                                                       @NotNull NewVirtualFileSystem fs) {
     if (childAttributes.isSymLink()) {
-      final String currentTarget = child.getCanonicalPath();
-      final String upToDateTarget = fs.resolveSymLink(child);
-      final String upToDateVfsTarget = upToDateTarget != null ? FileUtil.toSystemIndependentName(upToDateTarget) : null;
+      String currentTarget = child.getCanonicalPath();
+      String upToDateTarget = fs.resolveSymLink(child);
+      String upToDateVfsTarget = upToDateTarget != null ? FileUtil.toSystemIndependentName(upToDateTarget) : null;
+
       if (!Comparing.equal(currentTarget, upToDateVfsTarget)) {
         scheduleDeletion(child);
         scheduleReCreation(parent, child.getName(), childAttributes.isDirectory());
         return true;
       }
     }
+
     return false;
   }
 
-  private void scheduleWritableAttributeChange(@NotNull VirtualFileSystemEntry file, boolean currentWritable, boolean upToDateWritable) {
+  private void scheduleWritableAttributeChange(@NotNull VirtualFile file, boolean currentWritable, boolean upToDateWritable) {
     debug(LOG, "update r/w file=%s", file);
     myEvents.add(new VFilePropertyChangeEvent(null, file, VirtualFile.PROP_WRITABLE, currentWritable, upToDateWritable, true));
   }
 
-  private void scheduleUpdateContent(@NotNull VirtualFileSystemEntry file) {
+  private void scheduleUpdateContent(@NotNull VirtualFile file) {
     debug(LOG, "update file=%s", file);
     myEvents.add(new VFileContentChangeEvent(null, file, file.getModificationStamp(), -1, true));
   }
 
-  private void scheduleCreation(@NotNull VirtualFileSystemEntry parent, @NotNull String childName, final boolean isDirectory) {
+  private void scheduleCreation(@NotNull VirtualFile parent, @NotNull String childName, boolean isDirectory) {
     debug(LOG, "create parent=%s name=%s dir=%b", parent, childName, isDirectory);
     myEvents.add(new VFileCreateEvent(null, parent, childName, isDirectory, true, false));
   }
 
-  private void scheduleReCreation(@NotNull VirtualFileSystemEntry parent, @NotNull String childName, final boolean isDirectory) {
+  private void scheduleReCreation(@NotNull VirtualFile parent, @NotNull String childName, boolean isDirectory) {
     debug(LOG, "re-create parent=%s name=%s dir=%b", parent, childName, isDirectory);
     myEvents.add(new VFileCreateEvent(null, parent, childName, isDirectory, true, true));
   }
 
-  private void scheduleDeletion(@Nullable final VirtualFile file) {
+  private void scheduleDeletion(@Nullable VirtualFile file) {
     if (file == null) return;
     debug(LOG, "delete file=%s", file);
     myEvents.add(new VFileDeleteEvent(null, file, true));
   }
-
-  @NotNull
-  public List<VFileEvent> getEvents() {
-    return myEvents;
-  }
 }

From 7bbf8fcb05ae92ade323c58440893080790fbdab Mon Sep 17 00:00:00 2001
From: Eugene Zhuravlev <jeka@intellij.com>
Date: Tue, 26 Feb 2013 21:46:01 +0100
Subject: [PATCH 234/354] external build manager: recalculating cached path
 variables after their change

---
 .../compiler/server/BuildManager.java         | 26 ++++++++++++-------
 .../application/options/PathMacrosImpl.java   | 16 ++++++++++++
 2 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
index 019131d051b8..cc2f2c7b8d61 100644
--- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
+++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java
@@ -29,7 +29,10 @@ import com.intellij.execution.process.*;
 import com.intellij.execution.ui.RunContentDescriptor;
 import com.intellij.ide.PowerSaveMode;
 import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.*;
+import com.intellij.openapi.application.Application;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.ModalityState;
+import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.compiler.CompileContext;
 import com.intellij.openapi.components.ApplicationComponent;
 import com.intellij.openapi.diagnostic.Logger;
@@ -212,6 +215,7 @@ public class BuildManager implements ApplicationComponent{
   private final BuildMessageDispatcher myMessageDispatcher = new BuildMessageDispatcher();
   private volatile int myListenPort = -1;
   private volatile CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings myGlobals;
+  private int myGlobalsStamp = -1;
   @Nullable
   private final Charset mySystemCharset;
 
@@ -534,11 +538,7 @@ public class BuildManager implements ApplicationComponent{
             return;
           }
 
-          CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings globals = myGlobals;
-          if (globals == null) {
-            globals = buildGlobalSettings();
-            myGlobals = globals;
-          }
+          final CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings globals = buildGlobalSettings();
           CmdlineRemoteProto.Message.ControllerMessage.FSEvent currentFSChanges;
           final SequentialTaskExecutor projectTaskQueue;
           synchronized (myProjectDataMap) {
@@ -687,14 +687,22 @@ public class BuildManager implements ApplicationComponent{
     return "com.intellij.compiler.server.BuildManager";
   }
 
-  private static CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings buildGlobalSettings() {
+  private CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings buildGlobalSettings() {
+    final PathMacrosImpl pathVars = PathMacrosImpl.getInstanceEx();
+
+    final CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings cached = myGlobals;
+    if (cached != null && myGlobalsStamp == pathVars.getModificationStamp()) {
+      return cached;
+    }
+    myGlobals = null; // ensure the cache is cleared and stamp is current
+    myGlobalsStamp = pathVars.getModificationStamp();
+
     final Map<String, String> data = new HashMap<String, String>();
 
     for (Map.Entry<String, String> entry : PathMacrosImpl.getGlobalSystemMacros().entrySet()) {
       data.put(entry.getKey(), FileUtil.toSystemIndependentName(entry.getValue()));
     }
 
-    final PathMacros pathVars = PathMacros.getInstance();
     for (String name : pathVars.getAllMacroNames()) {
       final String path = pathVars.getValue(name);
       if (path != null) {
@@ -717,7 +725,7 @@ public class BuildManager implements ApplicationComponent{
       }
     }
 
-    return cmdBuilder.build();
+    return myGlobals = cmdBuilder.build();
   }
 
   private OSProcessHandler launchBuildProcess(Project project, final int port, final UUID sessionId) throws ExecutionException {
diff --git a/platform/projectModel-impl/src/com/intellij/application/options/PathMacrosImpl.java b/platform/projectModel-impl/src/com/intellij/application/options/PathMacrosImpl.java
index cc0ab83b813e..ed100e4dfed5 100644
--- a/platform/projectModel-impl/src/com/intellij/application/options/PathMacrosImpl.java
+++ b/platform/projectModel-impl/src/com/intellij/application/options/PathMacrosImpl.java
@@ -46,6 +46,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
   private static final Logger LOG = Logger.getInstance("#com.intellij.application.options.PathMacrosImpl");
   private final Map<String, String> myLegacyMacros = new HashMap<String, String>();
   private final Map<String, String> myMacros = new HashMap<String, String>();
+  private int myModificationStamp = 0;
   private final ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
   private final List<String> myIgnoredMacros = ContainerUtil.createLockFreeCopyOnWriteList();
 
@@ -196,6 +197,16 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
     if (!myIgnoredMacros.contains(name)) myIgnoredMacros.add(name);
   }
 
+  public int getModificationStamp() {
+    myLock.readLock().lock();
+    try {
+      return myModificationStamp;
+    }
+    finally {
+      myLock.readLock().unlock();
+    }
+  }
+
   public static Map<String, String> getGlobalSystemMacros() {
     final Map<String, String> map = new HashMap<String, String>();
     map.put(APPLICATION_HOME_MACRO_NAME, PathManager.getHomePath());
@@ -236,6 +247,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
       myMacros.clear();
     }
     finally {
+      myModificationStamp++;
       myLock.writeLock().unlock();
     }
   }
@@ -259,6 +271,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
       myMacros.put(name, value);
     }
     finally {
+      myModificationStamp++;
       myLock.writeLock().unlock();
     }
   }
@@ -271,6 +284,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
       myMacros.remove(name);
     }
     finally {
+      myModificationStamp++;
       myLock.writeLock().unlock();
     }
   }
@@ -283,6 +297,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
       LOG.assertTrue(value != null);
     }
     finally {
+      myModificationStamp++;
       myLock.writeLock().unlock();
     }
   }
@@ -322,6 +337,7 @@ public class PathMacrosImpl extends PathMacros implements ApplicationComponent,
       }
     }
     finally {
+      myModificationStamp++;
       myLock.writeLock().unlock();
     }
   }

From 018d30e15323f971fd0549f7b6b5fe04b85489f5 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Tue, 26 Feb 2013 22:15:23 +0100
Subject: [PATCH 235/354] display method parameters in chained lookup elements
 (IDEA-101789)

---
 .../codeInsight/completion/JavaChainLookupElement.java        | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java b/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
index 6a47ad3e1ea4..eb19c574c872 100644
--- a/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
+++ b/java/java-impl/src/com/intellij/codeInsight/completion/JavaChainLookupElement.java
@@ -21,6 +21,7 @@ import com.intellij.diagnostic.errordialog.Attachment;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.util.ClassConditionKey;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
@@ -94,7 +95,8 @@ public class JavaChainLookupElement extends LookupElementDecorator<LookupElement
     presentation.setItemText(qualifierText + "." + presentation.getItemText());
 
     if (myQualifier instanceof LookupItem && getQualifierObject() instanceof PsiClass) {
-      presentation.setTailText(JavaPsiClassReferenceElement.getLocationString((LookupItem)myQualifier));
+      String locationString = JavaPsiClassReferenceElement.getLocationString((LookupItem)myQualifier);
+      presentation.setTailText(StringUtil.notNullize(presentation.getTailText()) + locationString);
     }
   }
 

From acb83c2b3b65aa43d4de9b7f38e636825209ce3a Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Wed, 27 Feb 2013 10:44:17 +0400
Subject: [PATCH 236/354] CR-IC-41 Vertical line block match disapear view line
 in java code (IDEA-99572)

NPE was reported for the expression 'myComments.put(language, comments = LanguageParserDefinitions.INSTANCE.forLanguage(language).getCommentTokens());
---
 .../intellij/codeInsight/daemon/impl/IndentsPass.java | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
index 66421a2e4176..47830b9cba64 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/IndentsPass.java
@@ -545,7 +545,16 @@ public class IndentsPass extends TextEditorHighlightingPass implements DumbAware
       Language language = tokenType.getLanguage();
       TokenSet comments = myComments.get(language);
       if (comments == null) {
-        myComments.put(language, comments = LanguageParserDefinitions.INSTANCE.forLanguage(language).getCommentTokens());
+        ParserDefinition definition = LanguageParserDefinitions.INSTANCE.forLanguage(language);
+        if (definition != null) {
+          comments = definition.getCommentTokens();
+        }
+        if (comments == null) {
+          return fallbackColumn;
+        }
+        else {
+          myComments.put(language, comments);
+        }
       }
       if (comments.contains(tokenType) && indentOffset == it.getStart()) {
         String prefix = COMMENT_PREFIXES.get(tokenType);

From 5138cf8b724e2559d47ee07535a1de8b3ee15dc5 Mon Sep 17 00:00:00 2001
From: Bas Leijdekkers <basleijdekkers@gmail.com>
Date: Wed, 27 Feb 2013 09:47:04 +0100
Subject: [PATCH 237/354] IDEA-101742 ('Return of Date of Calendar field'
 inspection, shall have an option to ignore private methods)

---
 .../siyeh/InspectionGadgetsBundle.properties  |  1 +
 .../ReturnOfDateFieldInspection.java          | 25 ++++++++++++++++---
 .../ReturnOfDateField.html                    |  3 +++
 .../ReturnOfDateField.java}                   | 12 +++++----
 .../return_of_date_field/expected.xml         | 16 ++++++++++++
 .../ReturnOfDateFieldInspectionTest.java      | 12 +++++++++
 6 files changed, 61 insertions(+), 8 deletions(-)
 rename plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/{ReturnOfDateFieldInspection.java => return_of_date_field/ReturnOfDateField.java} (64%)
 create mode 100644 plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/expected.xml
 create mode 100644 plugins/InspectionGadgets/testsrc/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspectionTest.java

diff --git a/plugins/InspectionGadgets/src/com/siyeh/InspectionGadgetsBundle.properties b/plugins/InspectionGadgets/src/com/siyeh/InspectionGadgetsBundle.properties
index 712c06aba4a2..fdcff59f758f 100644
--- a/plugins/InspectionGadgets/src/com/siyeh/InspectionGadgetsBundle.properties
+++ b/plugins/InspectionGadgets/src/com/siyeh/InspectionGadgetsBundle.properties
@@ -334,6 +334,7 @@ return.of.collection.array.field.problem.descriptor.collection='return' of Colle
 return.of.collection.array.field.option=Ignore private methods returning an array or collection field
 return.date.calendar.field.display.name=Return of Date or Calendar field
 return.date.calendar.field.problem.descriptor=Return of ''{0}'' field <code>#ref</code> #loc
+return.date.calendar.field.quickfix=Return clone of ''{0}''
 accessing.non.public.field.of.another.object.display.name=Accessing a non-public field of another object
 accessing.non.public.field.of.another.object.problem.descriptor=Direct access of non-public field <code>#ref</code> on another object #loc
 call.to.date.tostring.display.name=Call to 'Date.toString()'
diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspection.java
index 601b285a53b0..1b28605e419f 100644
--- a/plugins/InspectionGadgets/src/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspection.java
+++ b/plugins/InspectionGadgets/src/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2011 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,10 @@
 package com.siyeh.ig.encapsulation;
 
 import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.codeInspection.ui.SingleCheckboxOptionsPanel;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.siyeh.InspectionGadgetsBundle;
 import com.siyeh.ig.BaseInspection;
@@ -25,9 +27,15 @@ import com.siyeh.ig.BaseInspectionVisitor;
 import com.siyeh.ig.InspectionGadgetsFix;
 import com.siyeh.ig.psiutils.TypeUtils;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
 
 public class ReturnOfDateFieldInspection extends BaseInspection {
 
+  @SuppressWarnings({"PublicField"})
+  public boolean ignorePrivateMethods = false;
+
   @Override
   @NotNull
   public String getDisplayName() {
@@ -41,6 +49,13 @@ public class ReturnOfDateFieldInspection extends BaseInspection {
     return InspectionGadgetsBundle.message("return.date.calendar.field.problem.descriptor", type);
   }
 
+  @Nullable
+  @Override
+  public JComponent createOptionsPanel() {
+    return new SingleCheckboxOptionsPanel(InspectionGadgetsBundle.message("return.of.null.ignore.private.option"),
+                                          this, "ignorePrivateMethods");
+  }
+
   @Override
   protected InspectionGadgetsFix buildFix(Object... infos) {
     return new ReturnOfDateFieldFix((String)infos[0]);
@@ -57,7 +72,7 @@ public class ReturnOfDateFieldInspection extends BaseInspection {
     @NotNull
     @Override
     public String getName() {
-      return "Return clone of '" + myType + '\'';
+      return InspectionGadgetsBundle.message("return.date.calendar.field.quickfix", myType);
     }
 
     @Override
@@ -81,7 +96,7 @@ public class ReturnOfDateFieldInspection extends BaseInspection {
     return new ReturnOfDateFieldVisitor();
   }
 
-  private static class ReturnOfDateFieldVisitor extends BaseInspectionVisitor {
+  private class ReturnOfDateFieldVisitor extends BaseInspectionVisitor {
 
     @Override
     public void visitReturnStatement(@NotNull PsiReturnStatement statement) {
@@ -90,6 +105,10 @@ public class ReturnOfDateFieldInspection extends BaseInspection {
       if (!(returnValue instanceof PsiReferenceExpression)) {
         return;
       }
+      final PsiMethod method = PsiTreeUtil.getParentOfType(statement, PsiMethod.class, true, PsiClass.class);
+      if (method == null || (ignorePrivateMethods && method.hasModifierProperty(PsiModifier.PRIVATE))) {
+        return;
+      }
       final PsiReferenceExpression fieldReference = (PsiReferenceExpression)returnValue;
       final PsiElement element = fieldReference.resolve();
       if (!(element instanceof PsiField)) {
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfDateField.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfDateField.html
index dbf8d9c177b9..3667f76c6d0e 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfDateField.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfDateField.html
@@ -8,6 +8,9 @@ result in an object having its state modified unexpectedly. While occasionally u
 reasons, this construct is inherently bug-prone.
 <!-- tooltip end -->
 <p>
+Use the checkbox below to ignore private methods returning a <b>java.lang.Date</b> or
+  <b>java.lang.Calendar</b> field.
+<p>
 <small>Powered by InspectionGadgets</small>
 </body>
 </html>
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/ReturnOfDateFieldInspection.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/ReturnOfDateField.java
similarity index 64%
rename from plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/ReturnOfDateFieldInspection.java
rename to plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/ReturnOfDateField.java
index 723bbf7a1183..158bda583544 100644
--- a/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/ReturnOfDateFieldInspection.java
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/ReturnOfDateField.java
@@ -1,8 +1,8 @@
-package com.siyeh.igtest.encapsulation;
+package com.siyeh.igtest.encapsulation.return_of_date_field;
 
 import java.util.*;
 
-public class ReturnOfDateFieldInspection
+public class ReturnOfDateField
 {
     private Date m_foo;
  //   private List<String> m_fooBar;
@@ -10,10 +10,10 @@ public class ReturnOfDateFieldInspection
 
     public static void main(String[] args)
     {
-        new ReturnOfDateFieldInspection(new Date());
+        new ReturnOfDateField(new Date());
     }
 
-    public ReturnOfDateFieldInspection(Date foo)
+    public ReturnOfDateField(Date foo)
     {
         m_foo = new Date(foo.getTime());
     }
@@ -35,5 +35,7 @@ public class ReturnOfDateFieldInspection
         return m_bar;
     }
 
-
+    private Date hidden() {
+        return m_foo;
+    }
 }
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/expected.xml b/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/expected.xml
new file mode 100644
index 000000000000..37d4ca193837
--- /dev/null
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/encapsulation/return_of_date_field/expected.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problems>
+  <problem>
+    <file>ReturnOfDateField.java</file>
+    <line>35</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Return of Date or Calendar field</problem_class>
+    <description>Return of 'java.util.Calendar' field &lt;code&gt;m_bar&lt;/code&gt; #loc</description>
+  </problem>
+
+  <problem>
+    <file>ReturnOfDateField.java</file>
+    <line>23</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Return of Date or Calendar field</problem_class>
+    <description>Return of 'java.util.Date' field &lt;code&gt;m_foo&lt;/code&gt; #loc</description>
+  </problem>
+</problems>
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspectionTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspectionTest.java
new file mode 100644
index 000000000000..e4789730693f
--- /dev/null
+++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/encapsulation/ReturnOfDateFieldInspectionTest.java
@@ -0,0 +1,12 @@
+package com.siyeh.ig.encapsulation;
+
+import com.siyeh.ig.IGInspectionTestCase;
+
+public class ReturnOfDateFieldInspectionTest extends IGInspectionTestCase {
+
+  public void test() throws Exception {
+    final ReturnOfDateFieldInspection tool = new ReturnOfDateFieldInspection();
+    tool.ignorePrivateMethods = true;
+    doTest("com/siyeh/igtest/encapsulation/return_of_date_field", tool);
+  }
+}
\ No newline at end of file

From 4cd794e853629c729131601f3d34e62e566ff8a4 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Mon, 25 Feb 2013 18:38:40 +0400
Subject: [PATCH 238/354] cleanup

---
 .../artifacts/instructions/ArtifactRootDescriptor.java    | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactRootDescriptor.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactRootDescriptor.java
index 24849efae998..4d4f7492768e 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactRootDescriptor.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/artifacts/instructions/ArtifactRootDescriptor.java
@@ -50,10 +50,6 @@ public abstract class ArtifactRootDescriptor extends BuildRootDescriptor {
     myDestinationInfo = destinationInfo;
   }
 
-  public final String getArtifactName() {
-    return myTarget.getId();
-  }
-
   @Override
   public String toString() {
     return getFullPath();
@@ -75,8 +71,8 @@ public abstract class ArtifactRootDescriptor extends BuildRootDescriptor {
   public FileFilter createFileFilter() {
     return new FileFilter() {
       @Override
-      public boolean accept(File pathname) {
-        return myFilter.accept(pathname.getAbsolutePath());
+      public boolean accept(File file) {
+        return myFilter.accept(file.getAbsolutePath());
       }
     };
   }

From 2e854bb86793b303e1ae7cea8eb7b7fbf60f8869 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Tue, 26 Feb 2013 19:47:18 +0400
Subject: [PATCH 239/354] don't ask user to setup source roots if user
 interaction isn't supposed (EA-44269)

---
 .../com/intellij/ide/util/PackageUtil.java    | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/java/java-impl/src/com/intellij/ide/util/PackageUtil.java b/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
index b124faa57c29..d0a0aa7f038c 100644
--- a/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
+++ b/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
@@ -210,7 +210,7 @@ public class PackageUtil {
     }
 
     if (psiDirectory == null) {
-      if (!checkSourceRootsConfigured(module)) return null;
+      if (!checkSourceRootsConfigured(module, askUserToCreate)) return null;
       final VirtualFile[] sourceRoots = ModuleRootManager.getInstance(module).getSourceRoots();
       List<PsiDirectory> directoryList = new ArrayList<PsiDirectory>();
       for (VirtualFile sourceRoot : sourceRoots) {
@@ -355,15 +355,22 @@ public class PackageUtil {
   }
 
   public static boolean checkSourceRootsConfigured(final Module module) {
+    return checkSourceRootsConfigured(module, true);
+  }
+
+  public static boolean checkSourceRootsConfigured(final Module module, final boolean askUserToSetupSourceRoots) {
     VirtualFile[] sourceRoots = ModuleRootManager.getInstance(module).getSourceRoots();
     if (sourceRoots.length == 0) {
-      Messages.showErrorDialog(
-          module.getProject(),
-          ProjectBundle.message("module.source.roots.not.configured.error", module.getName()),
-          ProjectBundle.message("module.source.roots.not.configured.title")
-        );
+      if (!askUserToSetupSourceRoots) {
+        return false;
+      }
 
-      ProjectSettingsService.getInstance(module.getProject()).showModuleConfigurationDialog(module.getName(), CommonContentEntriesEditor.NAME);
+      Project project = module.getProject();
+      Messages.showErrorDialog(project,
+                               ProjectBundle.message("module.source.roots.not.configured.error", module.getName()),
+                               ProjectBundle.message("module.source.roots.not.configured.title"));
+
+      ProjectSettingsService.getInstance(project).showModuleConfigurationDialog(module.getName(), CommonContentEntriesEditor.NAME);
 
       sourceRoots = ModuleRootManager.getInstance(module).getSourceRoots();
       if (sourceRoots.length == 0) {

From aceb2f1c793b9822aea533821a4ca337417bf38d Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Tue, 26 Feb 2013 20:00:09 +0400
Subject: [PATCH 240/354] EA-35970 - assert:
 VirtualFilePointerContainerImpl.getList

---
 .../com/intellij/openapi/roots/impl/libraries/LibraryImpl.java  | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/libraries/LibraryImpl.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/libraries/LibraryImpl.java
index 454634f8550d..0d699f7428f6 100644
--- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/libraries/LibraryImpl.java
+++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/libraries/LibraryImpl.java
@@ -213,6 +213,8 @@ public class LibraryImpl extends TraceableDisposable implements LibraryEx.Modifi
 
   @Override
   public List<String> getInvalidRootUrls(OrderRootType type) {
+    if (myDisposed) return Collections.emptyList();
+
     final List<VirtualFilePointer> pointers = myRoots.get(type).getList();
     List<String> invalidPaths = null;
     for (VirtualFilePointer pointer : pointers) {

From c29ec1434ace645e13794bb1d219e8c66cb09603 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 19:49:55 +0400
Subject: [PATCH 241/354] simplified

---
 ...ddCustomTagOrAttributeIntentionAction.java | 28 ++++++-------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
index faa61749ad05..ce0d01ef3cc2 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
@@ -16,22 +16,16 @@
 
 package com.intellij.codeInspection.htmlInspections;
 
-import com.intellij.CommonBundle;
-import com.intellij.codeInspection.InspectionProfile;
 import com.intellij.codeInspection.LocalQuickFix;
 import com.intellij.codeInspection.ModifiableModel;
 import com.intellij.codeInspection.ProblemDescriptor;
-import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.Messages;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
+import com.intellij.util.Consumer;
 import com.intellij.xml.XmlBundle;
 import org.jetbrains.annotations.NotNull;
 
-import java.io.IOException;
-
 /**
  * @author spleaner
  */
@@ -70,19 +64,13 @@ public class AddCustomTagOrAttributeIntentionAction implements LocalQuickFix {
 
   public void applyFix(@NotNull final Project project, @NotNull final ProblemDescriptor descriptor) {
     final PsiElement element = descriptor.getPsiElement();
-    final PsiFile file = element.getContainingFile();
 
-    final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
-    final InspectionProfile inspectionProfile = profileManager.getInspectionProfile();
-    final ModifiableModel model = inspectionProfile.getModifiableModel();
-    final LocalInspectionToolWrapper wrapper = (LocalInspectionToolWrapper)model.getInspectionTool(myInspectionName, element);
-    final HtmlUnknownTagInspection inspection = (HtmlUnknownTagInspection)wrapper.getTool();
-    inspection.addCustomPropertyName(myName);
-    try {
-      model.commit();
-    }
-    catch (IOException e) {
-      Messages.showErrorDialog(project, e.getMessage(), CommonBundle.getErrorTitle());
-    }
+    InspectionProjectProfileManager.getInstance(project).getInspectionProfile().modifyProfile(new Consumer<ModifiableModel>() {
+      @Override
+      public void consume(ModifiableModel model) {
+        HtmlUnknownTagInspection tool = (HtmlUnknownTagInspection)model.getUnwrappedTool(myInspectionName, element);
+        tool.addCustomPropertyName(myName);
+      }
+    });
   }
 }

From 7aad3a9481f3e6abb27aee803745fe2b9b964f0f Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 19:51:44 +0400
Subject: [PATCH 242/354] simplified

---
 ...dHtmlTagOrAttributeToCustomsIntention.java | 25 +++++++------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
index 9b8d73230b69..b655f96a84e5 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
@@ -16,22 +16,18 @@
 
 package com.intellij.codeInspection.htmlInspections;
 
-import com.intellij.CommonBundle;
 import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.codeInspection.InspectionProfile;
 import com.intellij.codeInspection.ModifiableModel;
-import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.Messages;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
 import com.intellij.psi.PsiFile;
+import com.intellij.util.Consumer;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.xml.XmlBundle;
 import org.jetbrains.annotations.NotNull;
 
-import java.io.IOException;
-
 /**
  * @author Maxim.Mossienko
  */
@@ -72,19 +68,16 @@ public class AddHtmlTagOrAttributeToCustomsIntention implements IntentionAction
     return true;
   }
 
-  public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+  public void invoke(@NotNull Project project, Editor editor, final PsiFile file) throws IncorrectOperationException {
     final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
     final InspectionProfile inspectionProfile = profileManager.getInspectionProfile();
-    final ModifiableModel model = inspectionProfile.getModifiableModel();
-    final LocalInspectionToolWrapper wrapper = (LocalInspectionToolWrapper)model.getInspectionTool(myInspectionName, file);
-    final XmlEntitiesInspection xmlEntitiesInspection = (XmlEntitiesInspection)wrapper.getTool();
-    xmlEntitiesInspection.setAdditionalEntries(myType, appendName(xmlEntitiesInspection.getAdditionalEntries(myType)));
-    try {
-      model.commit();
-    }
-    catch (IOException e) {
-      Messages.showErrorDialog(project, e.getMessage(), CommonBundle.getErrorTitle());
-    }
+    inspectionProfile.modifyProfile(new Consumer<ModifiableModel>() {
+      @Override
+      public void consume(ModifiableModel model) {
+        XmlEntitiesInspection xmlEntitiesInspection = (XmlEntitiesInspection)model.getUnwrappedTool(myInspectionName, file);
+        xmlEntitiesInspection.setAdditionalEntries(myType, appendName(xmlEntitiesInspection.getAdditionalEntries(myType)));
+      }
+    });
   }
 
   public boolean startInWriteAction() {

From 98f8254b0d64ff1cbf6f8a5c954c525f6ac4d125 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 19:52:10 +0400
Subject: [PATCH 243/354] simplified

---
 .../AddHtmlTagOrAttributeToCustomsIntention.java             | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
index b655f96a84e5..63be9c5ab72d 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
@@ -17,7 +17,6 @@
 package com.intellij.codeInspection.htmlInspections;
 
 import com.intellij.codeInsight.intention.IntentionAction;
-import com.intellij.codeInspection.InspectionProfile;
 import com.intellij.codeInspection.ModifiableModel;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
@@ -69,9 +68,7 @@ public class AddHtmlTagOrAttributeToCustomsIntention implements IntentionAction
   }
 
   public void invoke(@NotNull Project project, Editor editor, final PsiFile file) throws IncorrectOperationException {
-    final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(project);
-    final InspectionProfile inspectionProfile = profileManager.getInspectionProfile();
-    inspectionProfile.modifyProfile(new Consumer<ModifiableModel>() {
+    InspectionProjectProfileManager.getInstance(project).getInspectionProfile().modifyProfile(new Consumer<ModifiableModel>() {
       @Override
       public void consume(ModifiableModel model) {
         XmlEntitiesInspection xmlEntitiesInspection = (XmlEntitiesInspection)model.getUnwrappedTool(myInspectionName, file);

From 7d7ab03e824b924217998543f6c5c01c913b6216 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 20:09:59 +0400
Subject: [PATCH 244/354] capitalization

---
 .../com/intellij/tasks/actions/ChooseStacktraceDialog.java   | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/ChooseStacktraceDialog.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/ChooseStacktraceDialog.java
index 4a96fe165d58..1eeee125ada4 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/ChooseStacktraceDialog.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/actions/ChooseStacktraceDialog.java
@@ -31,7 +31,6 @@ import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import java.awt.*;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Date;
 
 /**
@@ -47,7 +46,7 @@ public class ChooseStacktraceDialog extends DialogWrapper {
   public ChooseStacktraceDialog(Project project, final Task issue) {
     super(project, false);
 
-    setTitle("Choose stacktrace to analyze");
+    setTitle("Choose Stacktrace to Analyze");
     Comment[] comments = issue.getComments();
     ArrayList<Comment> list = new ArrayList<Comment>(comments.length + 1);
     final String description = issue.getDescription();
@@ -56,7 +55,7 @@ public class ChooseStacktraceDialog extends DialogWrapper {
     }
     ContainerUtil.addAll(list, comments);
 
-    myList.setModel(new CollectionListModel(list));
+    myList.setModel(new CollectionListModel<Comment>(list));
     myList.setCellRenderer(new ColoredListCellRenderer() {
       @Override
       protected void customizeCellRenderer(JList list, Object value, int index, boolean selected, boolean hasFocus) {

From 1e13b3ec4bcfea4b779552ece543712ac03e5d9b Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Tue, 26 Feb 2013 20:22:08 +0400
Subject: [PATCH 245/354] diagnostics

---
 xml/impl/src/com/intellij/xml/util/XmlUtil.java | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/xml/impl/src/com/intellij/xml/util/XmlUtil.java b/xml/impl/src/com/intellij/xml/util/XmlUtil.java
index fec8120c2442..e9c8abd6c2ba 100644
--- a/xml/impl/src/com/intellij/xml/util/XmlUtil.java
+++ b/xml/impl/src/com/intellij/xml/util/XmlUtil.java
@@ -359,19 +359,17 @@ public class XmlUtil {
     return XSLT_URI.equals(ns) || XINCLUDE_URI.equals(ns);
   }
 
-
   public static char getCharFromEntityRef(@NonNls String text) {
-    //LOG.assertTrue(text.startsWith("&#") && text.endsWith(";"));
-    if (text.charAt(1) != '#') {
-      try {
+    try {
+      if (text.charAt(1) != '#') {
         text = text.substring(1, text.length() - 1);
+        return XmlTagUtil.getCharacterByEntityName(text);
       }
-      catch (StringIndexOutOfBoundsException e) {
-        LOG.error("Cannot parse ref: '" + text + "'", e);
-      }
-      return XmlTagUtil.getCharacterByEntityName(text);
+      text = text.substring(2, text.length() - 1);
+    }
+    catch (StringIndexOutOfBoundsException e) {
+      LOG.error("Cannot parse ref: '" + text + "'", e);
     }
-    text = text.substring(2, text.length() - 1);
     try {
       int code;
       if (StringUtil.startsWithChar(text, 'x')) {

From 56223b0bd2f8183747fc02be0e5d4f2d7638acfa Mon Sep 17 00:00:00 2001
From: Alexander Zolotov <Alexander.Zolotov@jetbrains.com>
Date: Wed, 27 Feb 2013 13:46:44 +0400
Subject: [PATCH 246/354] WEB-6848 Map help button of the Emmet page

---
 .../intellij/application/options/emmet/EmmetConfigurable.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
index 5f69489785da..a8df5388e5c7 100644
--- a/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
+++ b/xml/impl/src/com/intellij/application/options/emmet/EmmetConfigurable.java
@@ -92,7 +92,7 @@ public class EmmetConfigurable implements SearchableConfigurable, Disposable, Co
   @NotNull
   @Override
   public String getId() {
-    return "reference.settingsdialog.emmet";
+    return "reference.idesettings.emmet";
   }
 
   @Nullable

From 85a85ee9076169a9b3efcc7ead617ea2b64839d7 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 11:12:07 +0100
Subject: [PATCH 247/354] Test cleanup

---
 .../openapi/vfs/local/FileWatcherTest.java    | 78 +++++++++----------
 1 file changed, 38 insertions(+), 40 deletions(-)

diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/local/FileWatcherTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/local/FileWatcherTest.java
index 725790e02f51..547ebae00190 100644
--- a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/local/FileWatcherTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/local/FileWatcherTest.java
@@ -21,7 +21,6 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.io.FileUtilRt;
 import com.intellij.openapi.util.io.IoTestUtil;
 import com.intellij.openapi.vfs.*;
 import com.intellij.openapi.vfs.impl.local.FileWatcher;
@@ -290,17 +289,17 @@ public class FileWatcherTest extends PlatformLangTestCase {
   }
 
   public void testDirectoryOverlapping() throws Exception {
-    final File topDir = FileUtil.createTempDirectory("top.", null);
-    final File fileInTopDir = new File(topDir, "file1.txt"); FileUtilRt.createIfNotExists(fileInTopDir);
-    final File subDir = new File(topDir, "sub");  FileUtil.createDirectory(subDir);
-    final File fileInSubDir = new File(subDir, "file2.txt"); FileUtilRt.createIfNotExists(fileInSubDir);
-    final File sideDir = FileUtil.createTempDirectory("side.", null);
-    final File fileInSideDir = new File(sideDir, "file3.txt"); FileUtilRt.createIfNotExists(fileInSideDir);
+    File topDir = IoTestUtil.createTestDir("top");
+    File fileInTopDir = IoTestUtil.createTestFile(topDir, "file1.txt");
+    File subDir = IoTestUtil.createTestDir(topDir, "sub");
+    File fileInSubDir = IoTestUtil.createTestFile(subDir, "file2.txt");
+    File sideDir = IoTestUtil.createTestDir("side");
+    File fileInSideDir = IoTestUtil.createTestFile(sideDir, "file3.txt");
     refresh(topDir);
     refresh(sideDir);
 
-    final LocalFileSystem.WatchRequest requestForSubDir = watch(subDir);
-    final LocalFileSystem.WatchRequest requestForSideDir = watch(sideDir);
+    LocalFileSystem.WatchRequest requestForSubDir = watch(subDir);
+    LocalFileSystem.WatchRequest requestForSideDir = watch(sideDir);
     try {
       myAccept = true;
       FileUtil.writeToFile(fileInTopDir, "new content");
@@ -308,7 +307,7 @@ public class FileWatcherTest extends PlatformLangTestCase {
       FileUtil.writeToFile(fileInSideDir, "new content");
       assertEvent(VFileContentChangeEvent.class, fileInSubDir.getAbsolutePath(), fileInSideDir.getAbsolutePath());
 
-      final LocalFileSystem.WatchRequest requestForTopDir = watch(topDir);
+      LocalFileSystem.WatchRequest requestForTopDir = watch(topDir);
       try {
         myAccept = true;
         FileUtil.writeToFile(fileInTopDir, "newer content");
@@ -577,14 +576,14 @@ public class FileWatcherTest extends PlatformLangTestCase {
 
 
   @NotNull
-  private LocalFileSystem.WatchRequest watch(final File watchFile) {
+  private LocalFileSystem.WatchRequest watch(File watchFile) {
     return watch(watchFile, true);
   }
 
   @NotNull
   private LocalFileSystem.WatchRequest watch(final File watchFile, final boolean recursive) {
     final Ref<LocalFileSystem.WatchRequest> request = Ref.create();
-    getEvents("events to add watch "+watchFile, new Runnable() {
+    getEvents("events to add watch " + watchFile, new Runnable() {
       @Override
       public void run() {
         request.set(myFileSystem.addRootToWatch(watchFile.getAbsolutePath(), recursive));
@@ -604,8 +603,8 @@ public class FileWatcherTest extends PlatformLangTestCase {
     });
   }
 
-  private VirtualFile refresh(final File file) {
-    final VirtualFile vFile = myFileSystem.refreshAndFindFileByIoFile(file);
+  private VirtualFile refresh(File file) {
+    VirtualFile vFile = myFileSystem.refreshAndFindFileByIoFile(file);
     assertNotNull(file.toString(), vFile);
     VfsUtilCore.visitChildrenRecursively(vFile, new VirtualFileVisitor() {
       @Override
@@ -617,10 +616,10 @@ public class FileWatcherTest extends PlatformLangTestCase {
     return vFile;
   }
 
-  private void delete(@NotNull final File file) throws IOException {
-    final VirtualFile vFile = myFileSystem.findFileByIoFile(file);
+  private void delete(File file) throws IOException {
+    VirtualFile vFile = myFileSystem.findFileByIoFile(file);
     if (vFile != null) {
-      final AccessToken token = ApplicationManager.getApplication().acquireWriteActionLock(getClass());
+      AccessToken token = ApplicationManager.getApplication().acquireWriteActionLock(getClass());
       try {
         vFile.delete(this);
       }
@@ -633,28 +632,7 @@ public class FileWatcherTest extends PlatformLangTestCase {
     }
   }
 
-  private void assertEvent(final Class<? extends VFileEvent> type, final String... paths) {
-    final List<VFileEvent> events = getEvents(type+"",null);
-    assertEquals(events.toString(), paths.length, events.size());
-
-    final Set<String> pathSet = ContainerUtil.map2Set(paths, new Function<String, String>() {
-      @Override
-      public String fun(final String path) {
-        return FileUtil.toSystemIndependentName(path);
-      }
-    });
-
-    for (final VFileEvent event : events) {
-      assertTrue(event.toString(), type.isInstance(event));
-
-      final VirtualFile eventFile = event.getFile();
-      assertNotNull(event.toString(), eventFile);
-
-      assertTrue(eventFile + " not in " + Arrays.toString(paths), pathSet.remove(eventFile.getPath()));
-    }
-  }
-
-  private List<VFileEvent> getEvents(String msg, @Nullable final Runnable action) {
+  private List<VFileEvent> getEvents(String msg, @Nullable Runnable action) {
     LOG.debug("** waiting for " + msg + "...");
     myAccept = true;
 
@@ -675,7 +653,8 @@ public class FileWatcherTest extends PlatformLangTestCase {
 
     LOG.debug("** waited for " + timeout);
     myFileSystem.refresh(false);
-    final ArrayList<VFileEvent> result;
+
+    ArrayList<VFileEvent> result;
     synchronized (myEvents) {
       result = new ArrayList<VFileEvent>(myEvents);
       myEvents.clear();
@@ -683,4 +662,23 @@ public class FileWatcherTest extends PlatformLangTestCase {
     LOG.debug("** events: " + result.size());
     return result;
   }
+
+  private void assertEvent(Class<? extends VFileEvent> type, String... paths) {
+    List<VFileEvent> events = getEvents(String.valueOf(type), null);
+    assertEquals(events.toString(), paths.length, events.size());
+
+    Set<String> pathSet = ContainerUtil.map2Set(paths, new Function<String, String>() {
+      @Override
+      public String fun(final String path) {
+        return FileUtil.toSystemIndependentName(path);
+      }
+    });
+
+    for (VFileEvent event : events) {
+      assertTrue(event.toString(), type.isInstance(event));
+      VirtualFile eventFile = event.getFile();
+      assertNotNull(event.toString(), eventFile);
+      assertTrue(eventFile + " not in " + Arrays.toString(paths), pathSet.remove(eventFile.getPath()));
+    }
+  }
 }

From 405214430629d9544b25b456713d2398bf26000b Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 11:21:40 +0100
Subject: [PATCH 248/354] Utility method extracted

---
 .../intellij/psi/impl/source/PsiFileImpl.java | 80 +++++--------------
 .../psi/impl/source/tree/TreeUtil.java        | 58 +++++++++++++-
 2 files changed, 76 insertions(+), 62 deletions(-)

diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
index 7a2ba7eda4bd..b4b0ef408cee 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java
@@ -61,7 +61,6 @@ import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.PatchedWeakReference;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.text.CharArrayUtil;
-import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -279,7 +278,7 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
       @Override
       protected void visitNode(TreeElement node) {
         CompositeElement parent = node.getTreeParent();
-        if (parent != null && skipNode(builder, parent, node)) {
+        if (parent != null && TreeUtil.skipNode(builder, parent, node)) {
           return;
         }
 
@@ -960,79 +959,38 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
   private static final Key<StubTree> STUB_TREE_IN_PARSED_TREE = new Key<StubTree>("STUB_TREE_IN_PARSED_TREE");
 
   public StubTree calcStubTree() {
-    final FileElement fileElement = calcTreeElement();
+    FileElement fileElement = calcTreeElement();
     synchronized (PsiLock.LOCK) {
       StubTree tree = fileElement.getUserData(STUB_TREE_IN_PARSED_TREE);
+
       if (tree == null) {
         IElementType contentElementType = getContentElementType();
         if (!(contentElementType instanceof IStubFileElementType)) {
           VirtualFile vFile = getVirtualFile();
-          @NonNls String builder = "ContentElementType: " + contentElementType + "; file: " + this +
-          "\n\t" + "Boolean.TRUE.equals(getUserData(BUILDING_STUB)) = " + Boolean.TRUE.equals(getUserData(BUILDING_STUB)) +
-          "\n\t" + "getTreeElement() = " + getTreeElement() +
-          "\n\t" + "vFile instanceof VirtualFileWithId = " + (vFile instanceof VirtualFileWithId) +
-          "\n\t" + "StubUpdatingIndex.canHaveStub(vFile) = " + StubTreeLoader.getInstance().canHaveStub(vFile);
-          LOG.error(builder);
+          LOG.error("ContentElementType: " + contentElementType + "; file: " + this +
+                    "\n\t" + "Boolean.TRUE.equals(getUserData(BUILDING_STUB)) = " + Boolean.TRUE.equals(getUserData(BUILDING_STUB)) +
+                    "\n\t" + "getTreeElement() = " + getTreeElement() +
+                    "\n\t" + "vFile instanceof VirtualFileWithId = " + (vFile instanceof VirtualFileWithId) +
+                    "\n\t" + "StubUpdatingIndex.canHaveStub(vFile) = " + StubTreeLoader.getInstance().canHaveStub(vFile));
         }
-        final StubElement currentStubTree = ((IStubFileElementType)contentElementType).getBuilder().buildStubTree(this);
+
+        StubElement currentStubTree = ((IStubFileElementType)contentElementType).getBuilder().buildStubTree(this);
         tree = new StubTree((PsiFileStub)currentStubTree);
-        bindFakeStubsToTree(tree);
+        try {
+          TreeUtil.bindStubsToTree(this, tree);
+        }
+        catch (TreeUtil.StubBindingException e) {
+          rebuildStub();
+          LOG.error("Stub and PSI element type mismatch in " + getName() + ": " + e.getMessage());
+        }
+
         fileElement.putUserData(STUB_TREE_IN_PARSED_TREE, tree);
       }
+
       return tree;
     }
   }
 
-  private void bindFakeStubsToTree(final StubTree stubTree) {
-    final PsiFileImpl file = this;
-
-    final Iterator<StubElement<?>> stubs = stubTree.getPlainList().iterator();
-    stubs.next();  // skip file root stub
-    final FileElement fileRoot = file.getTreeElement();
-    assert fileRoot != null;
-
-    bindStubs(fileRoot, stubs, ((IStubFileElementType)getContentElementType()).getBuilder());
-  }
-
-  @SuppressWarnings("deprecation")
-  private static boolean skipNode(@NotNull StubBuilder builder, @NotNull ASTNode parent, @NotNull ASTNode node) {
-    if (builder instanceof DefaultStubBuilder) {
-      return ((DefaultStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
-    }
-    else if (builder instanceof LightStubBuilder) {
-      return ((LightStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
-    }
-    else {
-      return builder.skipChildProcessingWhenBuildingStubs(parent, node.getElementType());
-    }
-  }
-
-  private void bindStubs(final ASTNode tree, final Iterator<StubElement<?>> stubs, final StubBuilder builder) {
-    ((TreeElement)tree).acceptTree(new RecursiveTreeElementWalkingVisitor() {
-      @Override
-      protected void visitNode(TreeElement node) {
-        CompositeElement parent = node.getTreeParent();
-        if (parent != null && skipNode(builder, parent, node)) {
-          return;
-        }
-
-        IElementType type = node.getElementType();
-        if (type instanceof IStubElementType && ((IStubElementType) type).shouldCreateStub(node)) {
-          final StubElement stub = stubs.hasNext() ? stubs.next() : null;
-          if (stub == null || stub.getStubType() != type) {
-            rebuildStub();
-            assert false : "Stub and PSI element type mismatch in " + getName() + ": stub:" + stub + ", AST:" + type;
-          }
-
-          //noinspection unchecked
-          ((StubBase)stub).setPsi(node.getPsi());
-        }
-
-        super.visitNode(node);
-      }
-    });
-  }
-
   private void rebuildStub() {
     final VirtualFile vFile = getVirtualFile();
 
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/tree/TreeUtil.java b/platform/core-impl/src/com/intellij/psi/impl/source/tree/TreeUtil.java
index a19ff2cafc8f..45318cabf795 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/tree/TreeUtil.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/tree/TreeUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -23,14 +23,19 @@ import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.Ref;
+import com.intellij.psi.StubBuilder;
 import com.intellij.psi.impl.DebugUtil;
+import com.intellij.psi.impl.source.PsiFileImpl;
+import com.intellij.psi.stubs.*;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.IStrongWhitespaceHolderElementType;
+import com.intellij.psi.tree.IStubFileElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Set;
 
@@ -376,4 +381,55 @@ public class TreeUtil {
     public CompositeElement strongWhiteSpaceHolder = null;
     public boolean isStrongElementOnRisingSlope = true;
   }
+
+  public static class StubBindingException extends RuntimeException {
+    public StubBindingException(String message) {
+      super(message);
+    }
+  }
+
+  public static void bindStubsToTree(@NotNull PsiFileImpl file, @NotNull StubTree stubTree) throws StubBindingException {
+    final Iterator<StubElement<?>> stubs = stubTree.getPlainList().iterator();
+    stubs.next();  // skip file root stub
+
+    FileElement tree = file.getTreeElement();
+    assert tree != null : file;
+
+    final StubBuilder builder = ((IStubFileElementType)file.getContentElementType()).getBuilder();
+    tree.acceptTree(new RecursiveTreeElementWalkingVisitor() {
+      @Override
+      protected void visitNode(TreeElement node) {
+        CompositeElement parent = node.getTreeParent();
+        if (parent != null && skipNode(builder, parent, node)) {
+          return;
+        }
+
+        IElementType type = node.getElementType();
+        if (type instanceof IStubElementType && ((IStubElementType)type).shouldCreateStub(node)) {
+          final StubElement stub = stubs.hasNext() ? stubs.next() : null;
+          if (stub == null || stub.getStubType() != type) {
+            throw new StubBindingException("stub:" + stub + ", AST:" + type);
+          }
+
+          //noinspection unchecked
+          ((StubBase)stub).setPsi(node.getPsi());
+        }
+
+        super.visitNode(node);
+      }
+    });
+  }
+
+  @SuppressWarnings("deprecation")
+  public static boolean skipNode(@NotNull StubBuilder builder, @NotNull ASTNode parent, @NotNull ASTNode node) {
+    if (builder instanceof DefaultStubBuilder) {
+      return ((DefaultStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
+    }
+    else if (builder instanceof LightStubBuilder) {
+      return ((LightStubBuilder)builder).skipChildProcessingWhenBuildingStubs(parent, node);
+    }
+    else {
+      return builder.skipChildProcessingWhenBuildingStubs(parent, node.getElementType());
+    }
+  }
 }

From 5895fb88bc8cd3f3a4e5655d245da79e152ef661 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 14:20:20 +0400
Subject: [PATCH 249/354] @NotNull

---
 .../src/com/intellij/util/xml/ElementPresentationManager.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xml/dom-openapi/src/com/intellij/util/xml/ElementPresentationManager.java b/xml/dom-openapi/src/com/intellij/util/xml/ElementPresentationManager.java
index 6f525602fc42..049ce0db2778 100644
--- a/xml/dom-openapi/src/com/intellij/util/xml/ElementPresentationManager.java
+++ b/xml/dom-openapi/src/com/intellij/util/xml/ElementPresentationManager.java
@@ -188,7 +188,7 @@ public abstract class ElementPresentationManager {
     return TypePresentationService.getDefaultTypeName(o.getClass());
   }
 
-  public static Icon getIcon(Object o) {
+  public static Icon getIcon(@NotNull Object o) {
     for (final Function<Object, Icon> function : ourIconProviders) {
       final Icon icon = function.fun(o);
       if (icon != null) {

From 299fa31cbf41489c7f77ca09914f0e0679979b8d Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 09:54:23 +0400
Subject: [PATCH 250/354] modifiers annotated

---
 .../groovy/lang/psi/api/auxiliary/modifiers/GrModifier.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/auxiliary/modifiers/GrModifier.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/auxiliary/modifiers/GrModifier.java
index 278a7261f1d1..40feb1ec82ac 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/auxiliary/modifiers/GrModifier.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/auxiliary/modifiers/GrModifier.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2010 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -25,6 +25,7 @@ import org.jetbrains.annotations.NonNls;
 public interface GrModifier extends PsiModifier {
   @NonNls String DEF = "def";
 
+  @GrModifierConstant
   String[] GROOVY_MODIFIERS =
     {PUBLIC, PROTECTED, PRIVATE, STATIC, ABSTRACT, FINAL, NATIVE, SYNCHRONIZED, STRICTFP, TRANSIENT, VOLATILE, DEF};
 

From e8ee4ac449104d9391da93ae979d070cb8378e57 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 11:36:08 +0400
Subject: [PATCH 251/354] 'create constructor matching super' for method with
 optional parameters

---
 plugins/groovy/src/META-INF/plugin.xml        |  1 +
 .../psi/impl/GroovyPsiElementFactoryImpl.java |  6 ++-
 .../impl/source/impl/GroovyTreeGenerator.java | 40 ++++++++++++++++
 .../psi/impl/synthetic/GrLightAnnotation.java | 47 ++++++++++++++++---
 .../impl/synthetic/GrLightModifierList.java   | 22 +++++++++
 5 files changed, 107 insertions(+), 9 deletions(-)
 create mode 100644 plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/source/impl/GroovyTreeGenerator.java

diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml
index 3c82201b05b5..02f721375eaa 100644
--- a/plugins/groovy/src/META-INF/plugin.xml
+++ b/plugins/groovy/src/META-INF/plugin.xml
@@ -503,6 +503,7 @@
     <postStartupActivity implementation="org.jetbrains.plugins.groovy.mvc.MvcProjectWithoutLibraryNotificator"/>
 
     <treeCopyHandler implementation="org.jetbrains.plugins.groovy.lang.GroovyChangeUtilSupport"/>
+    <treeGenerator implementation="org.jetbrains.plugins.groovy.lang.psi.impl.source.impl.GroovyTreeGenerator" order="first"/>
 
     <copyPastePreProcessor implementation="org.jetbrains.plugins.groovy.editor.GroovyLiteralCopyPasteProcessor"/>
     <copyPastePostProcessor implementation="org.jetbrains.plugins.groovy.editor.GroovyReferenceCopyPasteProcessor"/>
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
index 2f568cfa9a34..96d4e0c41b4a 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
@@ -421,8 +421,10 @@ public class GroovyPsiElementFactoryImpl extends GroovyPsiElementFactory {
   }
 
   public PsiElement createModifierFromText(String name) {
-    final GroovyFileBase file = createGroovyFileChecked(name + "\"foo\"() {}");
-    return file.getTopLevelDefinitions()[0].getFirstChild().getFirstChild();
+    final GroovyFileBase file = createGroovyFileChecked(name + "foo() {}");
+    final GrTopLevelDefinition[] definitions = file.getTopLevelDefinitions();
+    if (definitions.length != 1) throw new IncorrectOperationException(name);
+    return definitions[0].getFirstChild().getFirstChild();
   }
 
   public GrCodeBlock createMethodBodyFromText(String text) {
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/source/impl/GroovyTreeGenerator.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/source/impl/GroovyTreeGenerator.java
new file mode 100644
index 000000000000..9caaaf31c4b6
--- /dev/null
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/source/impl/GroovyTreeGenerator.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.groovy.lang.psi.impl.source.impl;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.source.tree.TreeElement;
+import com.intellij.psi.impl.source.tree.TreeGenerator;
+import com.intellij.util.CharTable;
+import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
+
+public class GroovyTreeGenerator implements TreeGenerator {
+  @Override
+  public TreeElement generateTreeFor(PsiElement original, CharTable table, PsiManager manager) {
+
+    if (original instanceof GrModifierList) {
+      final String text = original.getText();
+      assert text != null : "Text is null for " + original + "; " + original.getClass();
+
+      final GrModifierList modifierList = GroovyPsiElementFactory.getInstance(manager.getProject()).createModifierList(text);
+      return (TreeElement)modifierList.getNode();
+    }
+
+    return null;
+  }
+}
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightAnnotation.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightAnnotation.java
index 19592353d2d9..bbf33c3798c3 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightAnnotation.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightAnnotation.java
@@ -17,10 +17,9 @@ package org.jetbrains.plugins.groovy.lang.psi.impl.synthetic;
 
 import com.intellij.lang.Language;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.PsiAnnotationMemberValue;
-import com.intellij.psi.PsiAnnotationOwner;
-import com.intellij.psi.PsiJavaCodeReferenceElement;
-import com.intellij.psi.PsiManager;
+import com.intellij.psi.*;
+import com.intellij.psi.impl.PsiImplUtil;
+import com.intellij.psi.impl.light.LightClassReference;
 import com.intellij.psi.impl.light.LightElement;
 import com.intellij.psi.meta.PsiMetaData;
 import com.intellij.util.containers.ContainerUtilRt;
@@ -28,6 +27,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
+import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotationNameValuePair;
@@ -87,6 +87,15 @@ public class GrLightAnnotation extends LightElement implements GrAnnotation {
     return "light groovy annotation";
   }
 
+  @Override
+  public String getText() {
+    StringBuilder buffer = new StringBuilder();
+    buffer.append('@').append(myQualifiedName);
+    buffer.append(myAnnotationArgList.getText());
+
+    return buffer.toString();
+  }
+
   @Override
   public String getQualifiedName() {
     return myQualifiedName;
@@ -94,17 +103,25 @@ public class GrLightAnnotation extends LightElement implements GrAnnotation {
 
   @Override
   public PsiJavaCodeReferenceElement getNameReferenceElement() {
-    return null;  
+    final GroovyResolveResult resolveResult = myRef.advancedResolve();
+    final PsiElement resolved = resolveResult.getElement();
+
+    if (resolved instanceof PsiClass) {
+      return new LightClassReference(getManager(), getClassReference().getText(), (PsiClass)resolved, resolveResult.getSubstitutor());
+    }
+    else {
+      return null;
+    }
   }
 
   @Override
   public PsiAnnotationMemberValue findAttributeValue(@NonNls String attributeName) {
-    return null;
+    return PsiImplUtil.findAttributeValue(this, attributeName);
   }
 
   @Override
   public PsiAnnotationMemberValue findDeclaredAttributeValue(@NonNls String attributeName) {
-    return null;
+    return PsiImplUtil.findDeclaredAttributeValue(this, attributeName);
   }
 
   @Override
@@ -170,5 +187,21 @@ public class GrLightAnnotation extends LightElement implements GrAnnotation {
     public String toString() {
       return "light annotation argument list";
     }
+
+    @Override
+    public String getText() {
+      if (myAttributes.isEmpty()) return "";
+
+      StringBuilder buffer = new StringBuilder();
+      buffer.append('(');
+
+      for (GrAnnotationNameValuePair attribute : myAttributes) {
+        buffer.append(attribute.getText());
+        buffer.append(',');
+      }
+      if (!myAttributes.isEmpty()) buffer.deleteCharAt(buffer.length() - 1);
+      buffer.append(')');
+      return buffer.toString();
+    }
   }
 }
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightModifierList.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightModifierList.java
index e274d65963da..b10e50329609 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightModifierList.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/synthetic/GrLightModifierList.java
@@ -22,6 +22,7 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
+import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifier;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierFlags;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.annotation.GrAnnotation;
@@ -133,6 +134,27 @@ public class GrLightModifierList extends LightElement implements GrModifierList
     return "GrModifierList";
   }
 
+  @Override
+  public String getText() {
+    StringBuilder buffer = new StringBuilder();
+    for (GrAnnotation annotation : myAnnotations) {
+      buffer.append(annotation.getText());
+      buffer.append(' ');
+    }
+
+    for (@GrModifier.GrModifierConstant String modifier : GrModifier.GROOVY_MODIFIERS) {
+      if (hasExplicitModifier(modifier)) {
+        buffer.append(modifier);
+        buffer.append(' ');
+      }
+    }
+
+    if (buffer.length() > 0) {
+      buffer.delete(buffer.length() - 1, buffer.length());
+    }
+    return buffer.toString();
+  }
+
   @NotNull
   public PsiElement[] getModifiers() {
     return PsiElement.EMPTY_ARRAY;

From 386da2bd0de6c88af90c66c126fb85f16102c60d Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 11:59:44 +0400
Subject: [PATCH 252/354] IDEA-101771: convert to Java -- javadocs for top
 classes

---
 .../convertToJava/ClassGenerator.java         |  4 +++-
 .../convertToJava/ClassItemGeneratorImpl.java | 20 ++++---------------
 .../convertToJava/GenerationUtil.java         | 14 ++++++++++++-
 .../convertGroovyToJava/file/groovyDoc.java   |  3 +++
 4 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassGenerator.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassGenerator.java
index 6fc2cd502d58..adaaa3ff3a9f 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassGenerator.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -65,6 +65,8 @@ public class ClassGenerator {
       writePackageStatement(text, containingFile.getPackageDefinition());
     }
 
+    GenerationUtil.writeDocComment(text, typeDefinition, true);
+
     boolean isEnum = typeDefinition.isEnum();
     boolean isAnnotationType = typeDefinition.isAnnotationType();
     boolean isInterface = typeDefinition.isInterface();
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassItemGeneratorImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassItemGeneratorImpl.java
index cdc65c868d4e..97d1caba3cd3 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassItemGeneratorImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassItemGeneratorImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,7 +20,6 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.light.LightMethodBuilder;
-import com.intellij.psi.javadoc.PsiDocComment;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashSet;
 import org.jetbrains.annotations.NotNull;
@@ -72,7 +71,7 @@ public class ClassItemGeneratorImpl implements ClassItemGenerator {
 
   @Override
   public void writeEnumConstant(StringBuilder builder, GrEnumConstant constant) {
-    writeDocComment(builder, constant, false);
+    GenerationUtil.writeDocComment(builder, constant, false);
     builder.append(constant.getName());
 
     final GrArgumentList argumentList = constant.getArgumentList();
@@ -105,7 +104,7 @@ public class ClassItemGeneratorImpl implements ClassItemGenerator {
   public void writeMethod(StringBuilder builder, PsiMethod method) {
     if (method == null) return;
 
-    writeDocComment(builder, method, true);
+    GenerationUtil.writeDocComment(builder, method, true);
 
     String name = method.getName();
 
@@ -303,7 +302,7 @@ public class ClassItemGeneratorImpl implements ClassItemGenerator {
     GrVariable[] variables = variableDeclaration.getVariables();
 
     if (variables.length > 0 && variables[0] instanceof PsiField) {
-      writeDocComment(mainBuilder, ((PsiField)variables[0]), true);
+      GenerationUtil.writeDocComment(mainBuilder, ((PsiField)variables[0]), true);
     }
 
     StringBuilder builder = new StringBuilder();
@@ -588,15 +587,4 @@ public class ClassItemGeneratorImpl implements ClassItemGenerator {
 
     return false;
   }
-
-  private static void writeDocComment(StringBuilder buffer, PsiMember member, boolean addLineFeed) {
-    if (member instanceof PsiDocCommentOwner) {
-      final PsiDocComment comment = ((PsiDocCommentOwner)member).getDocComment();
-      if (comment != null) {
-        final String text = comment.getText();
-        buffer.append(text);
-        if (addLineFeed) buffer.append('\n');
-      }
-    }
-  }
 }
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/GenerationUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/GenerationUtil.java
index 41310269c86e..e067001797bc 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/GenerationUtil.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/GenerationUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,6 +20,7 @@ import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.javadoc.PsiDocComment;
 import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.containers.HashMap;
@@ -683,4 +684,15 @@ public class GenerationUtil {
 
     return null;
   }
+
+  static void writeDocComment(StringBuilder buffer, PsiMember member, boolean addLineFeed) {
+    if (member instanceof PsiDocCommentOwner) {
+      final PsiDocComment comment = ((PsiDocCommentOwner)member).getDocComment();
+      if (comment != null) {
+        final String text = comment.getText();
+        buffer.append(text);
+        if (addLineFeed) buffer.append('\n');
+      }
+    }
+  }
 }
diff --git a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/groovyDoc.java b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/groovyDoc.java
index 58aaba336097..4d3d793e6ec5 100644
--- a/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/groovyDoc.java
+++ b/plugins/groovy/testdata/refactoring/convertGroovyToJava/file/groovyDoc.java
@@ -1,3 +1,6 @@
+/**
+ * class comment
+ */
 public class Foo {
 /**
    * method comment

From b5c565c4624f38093b0ffd771f44c7cbb64c0dac Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 14:42:41 +0400
Subject: [PATCH 253/354] IDEA-93658 Groovy: surround with !(...)

---
 .../GroovySurroundDescriptor.java             |  3 +-
 .../NotAndParenthesesSurrounder.groovy        | 42 +++++++++++++++++++
 .../SurroundExpressionTest.groovy             |  4 +-
 .../expr/notAndParenthesesOnCommandExpr.test  |  3 ++
 .../expr/notAndParenthesesSurrounder.test     |  3 ++
 5 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/NotAndParenthesesSurrounder.groovy
 create mode 100644 plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesOnCommandExpr.test
 create mode 100644 plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesSurrounder.test

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/GroovySurroundDescriptor.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/GroovySurroundDescriptor.java
index 0db6cb2b1f21..9f7c7ec73268 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/GroovySurroundDescriptor.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/GroovySurroundDescriptor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -43,6 +43,7 @@ public class GroovySurroundDescriptor implements SurroundDescriptor {
     new ShouldFailWithTypeStatementsSurrounder(),
     //expressions: like in java
     new ParenthesisExprSurrounder(),
+    new NotAndParenthesesSurrounder(),
     new TypeCastSurrounder(),
 
     //groovy-specific
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/NotAndParenthesesSurrounder.groovy b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/NotAndParenthesesSurrounder.groovy
new file mode 100644
index 000000000000..535eccdec105
--- /dev/null
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/surroundWith/NotAndParenthesesSurrounder.groovy
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2000-2013 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 org.jetbrains.plugins.groovy.lang.surroundWith
+
+import com.intellij.openapi.util.TextRange
+import com.intellij.psi.PsiElement
+import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrParenthesizedExpression
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrUnaryExpression
+
+/**
+ * @author Max Medvedev
+ */
+class NotAndParenthesesSurrounder extends GroovyExpressionSurrounder {
+  @Override
+  protected TextRange surroundExpression(GrExpression expression, PsiElement context) {
+    GrUnaryExpression result = (GrUnaryExpression)GroovyPsiElementFactory.getInstance(expression.project).createExpressionFromText("!(a)", context)
+    replaceToOldExpression(((GrParenthesizedExpression)result.operand).operand, expression)
+    result = (GrUnaryExpression)expression.replaceWithExpression(result, true);
+    return new TextRange(result.textRange.endOffset, result.textRange.endOffset);
+
+  }
+
+  @Override
+  String getTemplateDescription() {
+    "!(expr)"
+  }
+}
diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurroundExpressionTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurroundExpressionTest.groovy
index 4e22a0e7abe3..b3824c990cb5 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurroundExpressionTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurroundExpressionTest.groovy
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -35,6 +35,8 @@ public class SurroundExpressionTest extends SurroundTestCase {
   public void testCommandArgList2() { doTest(new TypeCastSurrounder()) }
   public void testCommandArgList3() { doTest(new TypeCastSurrounder()) }
   public void testCommandArgList4() { doTest(new TypeCastSurrounder()) }
+  public void testNotAndParenthesesSurrounder() { doTest(new NotAndParenthesesSurrounder()) }
+  public void testNotAndParenthesesOnCommandExpr() { doTest(new NotAndParenthesesSurrounder()) }
 
   final String basePath = TestUtils.testDataPath + "groovy/surround/expr/"
 }
diff --git a/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesOnCommandExpr.test b/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesOnCommandExpr.test
new file mode 100644
index 000000000000..5f58fb82f45d
--- /dev/null
+++ b/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesOnCommandExpr.test
@@ -0,0 +1,3 @@
+<selection>print 2</selection>
+-----
+!(print(2))
\ No newline at end of file
diff --git a/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesSurrounder.test b/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesSurrounder.test
new file mode 100644
index 000000000000..2828a42c09a2
--- /dev/null
+++ b/plugins/groovy/testdata/groovy/surround/expr/notAndParenthesesSurrounder.test
@@ -0,0 +1,3 @@
+print <selection>2</selection>
+-----
+print !(2)
\ No newline at end of file

From 3d28899c0b3382982369b802661608a3a201dd78 Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Wed, 27 Feb 2013 14:57:00 +0400
Subject: [PATCH 254/354] Bug fix.

---
 .../idea/maven/importing/MavenRootModelAdapter.java | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
index 614dbce63f96..9597e89f5bc8 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenRootModelAdapter.java
@@ -325,13 +325,22 @@ public class MavenRootModelAdapter {
 
     String newPath = artifact.getPathForExtraArtifact(classifier, extension);
     String newUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, newPath) + JarFileSystem.JAR_SEPARATOR;
+
+    boolean urlExists = false;
+
     for (String url : library.getUrls(type)) {
-      if (newUrl.equals(url)) return;
+      if (newUrl.equals(url)) {
+        urlExists = true;
+        continue;
+      }
       if (clearAll || isRepositoryUrl(artifact, url)) {
         library.removeRoot(url, type);
       }
     }
-    library.addRoot(newUrl, type);
+
+    if (!urlExists) {
+      library.addRoot(newUrl, type);
+    }
   }
 
   private static boolean isRepositoryUrl(MavenArtifact artifact, String url) {

From 62d0ca853a11d0c3940a9a9801f358b291bf6d51 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 14:56:27 +0400
Subject: [PATCH 255/354] IDEA-101547 Please add a clock in fullscreen mode!
 After-review: get rid of magic numbers

---
 .../openapi/wm/impl/status/ClockPanel.java    | 39 ++++++++++++-------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
index 7b9e4890e371..fc663f8692cd 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -38,8 +38,17 @@ import static java.util.Calendar.*;
 /**
  * User: Vassiliy.Kudryashov
  */
-public class ClockPanel extends JComponent implements CustomStatusBarWidget{
+public class ClockPanel extends JComponent implements CustomStatusBarWidget {
   @NonNls public static final String WIDGET_ID = "Clock";
+  private static final int[] MASK = new int[]{
+    1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9,//top
+    1 << 0 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9,//top-left
+    1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 7 | 1 << 8 | 1 << 9,//top-right
+    1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9,//middle
+    1 << 0 | 1 << 2 | 1 << 6 | 1 << 8,//bottom-left
+    1 << 0 | 1 << 1 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9,//bottom-right
+    1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9//bottom
+  };//1005, 881, 927, 892, 325, 1019, 877 (geek mode)
 
   protected final Calendar myCalendar;
   private final Timer myTimer;
@@ -98,7 +107,8 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
     Container parent = getParent();
     if (isVisible() && parent != null) {
       height = parent.getSize().height - parent.getInsets().top - parent.getInsets().bottom;
-    } else {
+    }
+    else {
       height = super.getPreferredSize().height;
     }
     return new Dimension((int)(height * 2.75), height);
@@ -111,7 +121,7 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
 
   @Override
   public void paint(Graphics graphics) {
-    Graphics2D g = (Graphics2D) graphics.create();
+    Graphics2D g = (Graphics2D)graphics.create();
     try {
       g.setRenderingHint(KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
       g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
@@ -135,11 +145,11 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
       int y = 2;
       boolean eveningDot = !is24Hours && myCalendar.get(HOUR_OF_DAY) > 11;
       if (eveningDot) {
-        g.setStroke(new BasicStroke(thickness*2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
-        g.draw(new Line2D.Float(x + thickness, y + thickness, x+thickness, y + thickness + thickness / 20));
+        g.setStroke(new BasicStroke(thickness * 2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+        g.draw(new Line2D.Float(x + thickness, y + thickness, x + thickness, y + thickness + thickness / 20));
       }
       g.setStroke(new BasicStroke(thickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
-      if (hours>=10 ) paintDigit(g, x, y, w, h, thickness, hours / 10);
+      if (hours >= 10) paintDigit(g, x, y, w, h, thickness, hours / 10);
       x += w + thickness * 2;
       paintDigit(g, x, y, w, h, thickness, hours % 10);
       x += w + thickness * 2;
@@ -151,7 +161,8 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
       paintDigit(g, x, y, w, h, thickness, minutes / 10);
       x += w + thickness * 2;
       paintDigit(g, x, y, w, h, thickness, minutes % 10);
-    } finally {
+    }
+    finally {
       g.dispose();
     }
   }
@@ -162,12 +173,12 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget{
     float t54 = t * 5 / 4;
     float t34 = t * 3 / 4;
     float t2 = t / 2;
-    if ((digit & 1005) != 0) g.draw(new Line2D.Float(x + t54, y + t2, x + width - t54, y + t2));
-    if ((digit & 881) != 0) g.draw(new Line2D.Float(x + t2, y + t54, x + t2, y + h2 - t34));
-    if ((digit & 927) != 0) g.draw(new Line2D.Float(x + width - t2, y + t54, x + width - t2, y + h2 - t34));
-    if ((digit & 892) != 0) g.draw(new Line2D.Float(x + t54, y + h2, x + width - t54, y + h2));
-    if ((digit & 325) != 0) g.draw(new Line2D.Float(x + t2, y + h2 + t34, x + t2, y + height - t54));
-    if ((digit & 1019) != 0) g.draw(new Line2D.Float(x + width - t2, y + h2 + t34, x + width - t2, y + height - t54));
-    if ((digit & 877) != 0) g.draw(new Line2D.Float(x + t54, y + height - t2, x + width - t54, y + height - t2));
+    if ((digit & MASK[0]) != 0) g.draw(new Line2D.Float(x + t54, y + t2, x + width - t54, y + t2));
+    if ((digit & MASK[1]) != 0) g.draw(new Line2D.Float(x + t2, y + t54, x + t2, y + h2 - t34));
+    if ((digit & MASK[2]) != 0) g.draw(new Line2D.Float(x + width - t2, y + t54, x + width - t2, y + h2 - t34));
+    if ((digit & MASK[3]) != 0) g.draw(new Line2D.Float(x + t54, y + h2, x + width - t54, y + h2));
+    if ((digit & MASK[4]) != 0) g.draw(new Line2D.Float(x + t2, y + h2 + t34, x + t2, y + height - t54));
+    if ((digit & MASK[5]) != 0) g.draw(new Line2D.Float(x + width - t2, y + h2 + t34, x + width - t2, y + height - t54));
+    if ((digit & MASK[6]) != 0) g.draw(new Line2D.Float(x + t54, y + height - t2, x + width - t54, y + height - t2));
   }
 }

From bc39ba7f084b22baa25b4ae81d62c97fd9efb914 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 14:40:41 +0400
Subject: [PATCH 256/354] EA-43889 - IAE: XmlUtil.findNamespace

---
 .../src/com/intellij/xml/impl/schema/XmlNSDescriptorImpl.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/xml/impl/src/com/intellij/xml/impl/schema/XmlNSDescriptorImpl.java b/xml/impl/src/com/intellij/xml/impl/schema/XmlNSDescriptorImpl.java
index e98435727d90..1c704a01c3b3 100644
--- a/xml/impl/src/com/intellij/xml/impl/schema/XmlNSDescriptorImpl.java
+++ b/xml/impl/src/com/intellij/xml/impl/schema/XmlNSDescriptorImpl.java
@@ -93,9 +93,9 @@ public class XmlNSDescriptorImpl implements XmlNSDescriptorEx,Validator<XmlDocum
       if (equalsToSchemaName(tag, INCLUDE_TAG_NAME) ||
           equalsToSchemaName(tag, IMPORT_TAG_NAME)
         ) {
-        final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation");
+        final String schemaLocation = tag.getAttributeValue("schemaLocation");
         if (schemaLocation != null) {
-          final XmlFile xmlFile = XmlUtil.findNamespace(myFile, schemaLocation.getValue());
+          final XmlFile xmlFile = XmlUtil.findNamespace(myFile, schemaLocation);
           addDependency(xmlFile, visited);
         }
       } else if (equalsToSchemaName(tag, REDEFINE_TAG_NAME)) {

From 66a91b4180fa3910efedc88c46cd0296e0d371b3 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 14:51:32 +0400
Subject: [PATCH 257/354] EA-43515 - IAE: PsiManagerImpl.findFile

---
 .../psi/impl/include/FileIncludeManager.java  |  5 +-
 .../impl/include/FileIncludeManagerImpl.java  | 16 +++----
 .../model/resolve/RelaxIncludeIndex.java      | 48 +++++++++++--------
 3 files changed, 37 insertions(+), 32 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/psi/impl/include/FileIncludeManager.java b/platform/lang-api/src/com/intellij/psi/impl/include/FileIncludeManager.java
index 7d56a7e75cb2..3d3e7a04fd1c 100644
--- a/platform/lang-api/src/com/intellij/psi/impl/include/FileIncludeManager.java
+++ b/platform/lang-api/src/com/intellij/psi/impl/include/FileIncludeManager.java
@@ -23,6 +23,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiFileSystemItem;
 import com.intellij.util.Processor;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -34,9 +35,9 @@ public abstract class FileIncludeManager {
     return ServiceManager.getService(project, FileIncludeManager.class);
   }
 
-  public abstract VirtualFile[] getIncludedFiles(VirtualFile file, boolean compileTimeOnly);
+  public abstract VirtualFile[] getIncludedFiles(@NotNull VirtualFile file, boolean compileTimeOnly);
 
-  public abstract VirtualFile[] getIncludingFiles(VirtualFile file, boolean compileTimeOnly);
+  public abstract VirtualFile[] getIncludingFiles(@NotNull VirtualFile file, boolean compileTimeOnly);
 
   public abstract void processIncludingFiles(PsiFile context, Processor<Pair<VirtualFile, FileIncludeInfo>> processor);
 
diff --git a/platform/lang-impl/src/com/intellij/psi/impl/include/FileIncludeManagerImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/include/FileIncludeManagerImpl.java
index 01340d441c00..c141d5b270a4 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/include/FileIncludeManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/include/FileIncludeManagerImpl.java
@@ -21,10 +21,7 @@ import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.vfs.VfsUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
-import com.intellij.openapi.vfs.VirtualFileWithId;
+import com.intellij.openapi.vfs.*;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiFileFactory;
 import com.intellij.psi.PsiFileSystemItem;
@@ -38,6 +35,7 @@ import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.FactoryMap;
 import com.intellij.util.containers.HashMap;
 import com.intellij.util.containers.MultiMap;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
@@ -136,7 +134,7 @@ public class FileIncludeManagerImpl extends FileIncludeManager {
   }
 
   @Override
-  public VirtualFile[] getIncludedFiles(VirtualFile file, boolean compileTimeOnly) {
+  public VirtualFile[] getIncludedFiles(@NotNull VirtualFile file, boolean compileTimeOnly) {
     if (file instanceof VirtualFileWithId) {
       return myIncludedHolder.getAllFiles(file, compileTimeOnly);
     }
@@ -146,7 +144,7 @@ public class FileIncludeManagerImpl extends FileIncludeManager {
   }
 
   @Override
-  public VirtualFile[] getIncludingFiles(VirtualFile file, boolean compileTimeOnly) {
+  public VirtualFile[] getIncludingFiles(@NotNull VirtualFile file, boolean compileTimeOnly) {
     return myIncludingHolder.getAllFiles(file, compileTimeOnly);
   }
 
@@ -204,13 +202,13 @@ public class FileIncludeManagerImpl extends FileIncludeManager {
       RUNTIME_KEY = Key.create(runtimeKey);
     }
 
-    public VirtualFile[] getAllFiles(VirtualFile file, boolean compileTimeOnly) {
+    private VirtualFile[] getAllFiles(@NotNull VirtualFile file, boolean compileTimeOnly) {
       Set<VirtualFile> result = new HashSet<VirtualFile>();
       getFilesRecursively(file, compileTimeOnly, result);
-      return VfsUtil.toVirtualFileArray(result);
+      return VfsUtilCore.toVirtualFileArray(result);
     }
 
-    private void getFilesRecursively(VirtualFile file, boolean compileTimeOnly, Set<VirtualFile> result) {
+    private void getFilesRecursively(@NotNull VirtualFile file, boolean compileTimeOnly, Set<VirtualFile> result) {
       if (result.contains(file)) return;
       PsiFile psiFile = myPsiManager.findFile(file);
       if (psiFile == null) return;
diff --git a/xml/relaxng/src/org/intellij/plugins/relaxNG/model/resolve/RelaxIncludeIndex.java b/xml/relaxng/src/org/intellij/plugins/relaxNG/model/resolve/RelaxIncludeIndex.java
index 0d8c9c5de2cc..ab9beda8cc01 100644
--- a/xml/relaxng/src/org/intellij/plugins/relaxNG/model/resolve/RelaxIncludeIndex.java
+++ b/xml/relaxng/src/org/intellij/plugins/relaxNG/model/resolve/RelaxIncludeIndex.java
@@ -23,20 +23,23 @@ import org.jetbrains.annotations.NotNull;
 */
 public class RelaxIncludeIndex {
   public static boolean processForwardDependencies(XmlFile file, final PsiElementProcessor<XmlFile> processor) {
+    VirtualFile virtualFile = file.getVirtualFile();
+    if (virtualFile == null) {
+      return processor.execute(file);
+    }
     final Project project = file.getProject();
-    final VirtualFile[] files = FileIncludeManager.getManager(project).getIncludedFiles(file.getVirtualFile(), true);
+    final VirtualFile[] files = FileIncludeManager.getManager(project).getIncludedFiles(virtualFile, true);
 
     return processRelatedFiles(file, files, processor);
   }
 
   public static boolean processBackwardDependencies(@NotNull XmlFile file, PsiElementProcessor<XmlFile> processor) {
-    return processBackwardDependencies((PsiFile)file, processor);
-  }
-
-
-  private static boolean processBackwardDependencies(@NotNull PsiFile file, PsiElementProcessor<XmlFile> processor) {
+    VirtualFile virtualFile = file.getVirtualFile();
+    if (virtualFile == null) {
+      return processor.execute(file);
+    }
     final Project project = file.getProject();
-    final VirtualFile[] files = FileIncludeManager.getManager(project).getIncludingFiles(file.getVirtualFile(), true);
+    final VirtualFile[] files = FileIncludeManager.getManager(project).getIncludingFiles(virtualFile, true);
 
     return processRelatedFiles(file, files, processor);
   }
@@ -51,25 +54,28 @@ public class RelaxIncludeIndex {
     });
 
     for (final PsiFile psiFile : psiFiles) {
-      final FileType type = file.getFileType();
-      if (type == XmlFileType.INSTANCE && isRngFile(psiFile)) {
-        if (!processor.execute((XmlFile)psiFile)) {
-          return false;
-        }
-      } else if (type == RncFileType.getInstance()) {
-        if (!processor.execute((XmlFile)psiFile)) {
-          return false;
-        }
+      if (!processFile(psiFile, processor)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private static boolean processFile(PsiFile psiFile, PsiElementProcessor<XmlFile> processor) {
+    final FileType type = psiFile.getFileType();
+    if (type == XmlFileType.INSTANCE && isRngFile(psiFile)) {
+      if (!processor.execute((XmlFile)psiFile)) {
+        return false;
+      }
+    } else if (type == RncFileType.getInstance()) {
+      if (!processor.execute((XmlFile)psiFile)) {
+        return false;
       }
     }
     return true;
   }
 
   static boolean isRngFile(PsiFile psiFile) {
-    try {
-      return DomManager.getDomManager(psiFile.getProject()).getFileElement((XmlFile)psiFile, RngGrammar.class) != null;
-    } catch (ClassCastException e) {
-      return false; // fileType == XML && !instanceof XmlFile
-    }
+     return psiFile instanceof XmlFile && DomManager.getDomManager(psiFile.getProject()).getFileElement((XmlFile)psiFile, RngGrammar.class) != null;
   }
 }

From 6308a651a2b36cbf23cc50a1d8bede9cca09c6a0 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 12:16:34 +0100
Subject: [PATCH 258/354] lambda/method refs: inference exception variables
 (initial)

---
 .../source/resolve/PsiResolveHelperImpl.java  | 56 +++++++++++++++++++
 .../LambdaParamExceptionVariable.java         | 11 ++++
 .../NotThrownLambdaBodyReferencedMethod.java  | 19 +++++++
 ...aBodyReferencedMethodContradictBounds.java | 10 ++++
 .../lambda/exceptions/UnboundExceptions.java  | 29 ++++++++++
 .../ExceptionVariablesInferenceTest.java      | 47 ++++++++++++++++
 6 files changed, 172 insertions(+)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/LambdaParamExceptionVariable.java
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethod.java
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethodContradictBounds.java
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/UnboundExceptions.java
 create mode 100644 java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/ExceptionVariablesInferenceTest.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
index 386acc2ec493..27b69cc57dda 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/PsiResolveHelperImpl.java
@@ -15,7 +15,9 @@
  */
 package com.intellij.psi.impl.source.resolve;
 
+import com.intellij.codeInsight.ExceptionUtil;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.JavaSdkVersion;
 import com.intellij.openapi.projectRoots.JavaVersionService;
 import com.intellij.openapi.util.Computable;
@@ -32,6 +34,7 @@ import com.intellij.psi.scope.processor.MethodCandidatesProcessor;
 import com.intellij.psi.scope.processor.MethodResolverProcessor;
 import com.intellij.psi.scope.util.PsiScopesUtil;
 import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.util.InheritanceUtil;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.psi.util.TypeConversionUtil;
@@ -1147,6 +1150,10 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
                 }
                 return null;
               }
+              final Pair<PsiType, ConstraintType> inferredExceptionTypeConstraint = inferExceptionConstrains(typeParameter, expression, method, resolveResult.getSubstitutor());
+              if (inferredExceptionTypeConstraint != null) {
+                return inferredExceptionTypeConstraint;
+              }
             }
           }
         }
@@ -1190,6 +1197,55 @@ public class PsiResolveHelperImpl implements PsiResolveHelper {
     return result;
   }
 
+  private static Pair<PsiType, ConstraintType> inferExceptionConstrains(PsiTypeParameter typeParameter,
+                                                                        PsiExpression expression,
+                                                                        PsiMethod method,
+                                                                        PsiSubstitutor substitutor) {
+    final PsiClassType[] declaredExceptions = method.getThrowsList().getReferencedTypes();
+    for (PsiClassType exception : declaredExceptions) {
+      final PsiType substitute = substitutor.substitute(exception);
+      if (PsiUtil.resolveClassInType(substitute) == typeParameter) {
+        if (expression instanceof PsiLambdaExpression) {
+          final PsiElement body = ((PsiLambdaExpression)expression).getBody();
+          if (body != null) {
+            final List<PsiClassType> unhandledExceptions = ExceptionUtil.getUnhandledExceptions(body);
+            if (unhandledExceptions.isEmpty()) {
+              return inferUncheckedException(typeParameter, exception, method);
+            }
+          }
+        }
+        else if (expression instanceof PsiMethodReferenceExpression) {
+          final PsiElement resolve = ((PsiMethodReferenceExpression)expression).resolve();
+          if (resolve instanceof PsiMethod) {
+            final PsiClassType[] declaredThrowsList = ((PsiMethod)resolve).getThrowsList().getReferencedTypes();
+            for (PsiClassType psiClassType : declaredThrowsList) {
+              if (!ExceptionUtil.isUncheckedException(psiClassType)) return null;
+            }
+            return inferUncheckedException(typeParameter, exception, method);
+          }
+        }
+        break;
+      }
+    }
+    return null;
+  }
+
+  private static Pair<PsiType, ConstraintType> inferUncheckedException(PsiTypeParameter typeParameter,
+                                                                       PsiClassType exception,
+                                                                       PsiMethod method) {
+    final Project project = typeParameter.getProject();
+    final PsiClass runtimeException = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION, method.getResolveScope());
+    if (runtimeException != null) {
+      for (PsiType superType : exception.getSuperTypes()) {
+        if (!InheritanceUtil.isInheritorOrSelf(runtimeException, PsiUtil.resolveClassInType(superType), true)) {
+          return getFailedInferenceConstraint(typeParameter);
+        }
+      }
+      return Pair.<PsiType, ConstraintType>create(JavaPsiFacade.getElementFactory(project).createType(runtimeException, PsiSubstitutor.EMPTY), ConstraintType.EQUALS);
+    }
+    return null;
+  }
+
   private static Pair<PsiType, ConstraintType> inferFromConditionalExpression(PsiElement parent,
                                                                               PsiExpression methodCall,
                                                                               PsiTypeParameter typeParameter,
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/LambdaParamExceptionVariable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/LambdaParamExceptionVariable.java
new file mode 100644
index 000000000000..80d78a4e8deb
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/LambdaParamExceptionVariable.java
@@ -0,0 +1,11 @@
+class Test {
+    interface F<T extends Throwable> {
+        void _(T t) throws T;
+    }
+    <K extends Throwable> void foo(F<K> f) throws K { }
+
+    {
+        foo(<error descr="Cyclic inference">(t)->{}</error>);
+        <error descr="Unhandled exception: java.lang.ClassNotFoundException">foo((ClassNotFoundException t)->{});</error>
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethod.java
new file mode 100644
index 000000000000..0a46115c6e02
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethod.java
@@ -0,0 +1,19 @@
+class Test {
+
+    interface F<T extends Throwable> {
+        void _() throws T;
+    }
+    
+    void m1() { }
+    void m2() throws NullPointerException{ }
+    <K extends Throwable> void foo(F<K> f) throws K { }
+    
+    {
+        foo(()->{});
+        foo(()->{throw new NullPointerException();});
+
+        foo(this::m1);
+        foo(this::m2);
+    }
+    
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethodContradictBounds.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethodContradictBounds.java
new file mode 100644
index 000000000000..a2aa20ed8ee1
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/NotThrownLambdaBodyReferencedMethodContradictBounds.java
@@ -0,0 +1,10 @@
+class Test {
+    interface F<T extends ClassNotFoundException> {
+        void _() throws T;
+    }
+    <K extends ClassNotFoundException> void foo(F<K> f) throws K { }
+
+    {
+        <error descr="Unhandled exception: K">foo(() -> {});</error>
+    }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/UnboundExceptions.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/UnboundExceptions.java
new file mode 100644
index 000000000000..f049a1bad3f6
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/exceptions/UnboundExceptions.java
@@ -0,0 +1,29 @@
+class Test {
+
+    interface F<T extends Throwable> {
+        void _() throws T;
+    }
+
+    void m1() { }
+    void m2() throws ClassNotFoundException { }
+    void m3() throws Exception { }
+    
+    <K extends Throwable> void foo1(F<K> f) throws K { }
+    <K extends ClassNotFoundException> void foo2(F<K> f) throws K { }
+
+    {
+        <error descr="Inferred type 'java.lang.RuntimeException' for type parameter 'K' is not within its bound; should extend 'java.lang.ClassNotFoundException'">foo2(()->{})</error>;
+        foo2(()->{ <error descr="Unhandled exception: java.lang.ClassNotFoundException">throw new ClassNotFoundException();</error> });
+
+        <error descr="Inferred type 'java.lang.RuntimeException' for type parameter 'K' is not within its bound; should extend 'java.lang.ClassNotFoundException'">foo2(this::m1)</error>;
+        foo2(<error descr="Unhandled exception: java.lang.ClassNotFoundException">this::m2</error>);
+
+
+
+        foo1(()->{ <error descr="Unhandled exception: java.lang.ClassNotFoundException">throw new ClassNotFoundException();</error> });
+        foo1(()->{ <error descr="Unhandled exception: java.lang.Exception">throw new Exception();</error> });
+
+        foo1(<error descr="Unhandled exception: java.lang.ClassNotFoundException">this::m2</error>);
+        foo1(<error descr="Unhandled exception: java.lang.Exception">this::m3</error>);
+    }
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/ExceptionVariablesInferenceTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/ExceptionVariablesInferenceTest.java
new file mode 100644
index 000000000000..1e665ac000e2
--- /dev/null
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/ExceptionVariablesInferenceTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2000-2013 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.codeInsight.daemon.lambda;
+
+import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import org.jetbrains.annotations.NonNls;
+
+public class ExceptionVariablesInferenceTest extends LightDaemonAnalyzerTestCase {
+  @NonNls static final String BASE_PATH = "/codeInsight/daemonCodeAnalyzer/lambda/exceptions";
+
+  public void testUnboundExceptions() throws Exception {
+    doTest();
+  }
+
+  public void testNotThrownLambdaBodyReferencedMethod() throws Exception {
+    doTest();
+  }
+
+  public void testNotThrownLambdaBodyReferencedMethodContradictBounds() throws Exception {
+    doTest();
+  }
+
+  public void testLambdaParamExceptionVariable() throws Exception {
+    doTest();
+  }
+
+  private void doTest() throws Exception {
+    doTest(false);
+  }
+
+  private void doTest(final boolean checkWarnings) throws Exception {
+    doTest(BASE_PATH + "/" + getTestName(false) + ".java", checkWarnings, false);
+  }
+}

From ccf73a2721b98203cc26f7557699335781c934cc Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 15:22:01 +0400
Subject: [PATCH 259/354] EA-43315 - NPE: CssUriImpl.updateText

---
 .../src/com/intellij/psi/ElementManipulators.java | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/platform/core-api/src/com/intellij/psi/ElementManipulators.java b/platform/core-api/src/com/intellij/psi/ElementManipulators.java
index 654c46e3886f..66a48f0a8c11 100644
--- a/platform/core-api/src/com/intellij/psi/ElementManipulators.java
+++ b/platform/core-api/src/com/intellij/psi/ElementManipulators.java
@@ -37,15 +37,21 @@ public class ElementManipulators extends ClassExtension<ElementManipulator> {
   }
 
   public static <T extends PsiElement> ElementManipulator<T> getManipulator(@NotNull T element) {
+    //noinspection unchecked
     return INSTANCE.forClass(element.getClass());
   }
 
   public static int getOffsetInElement(final PsiElement element) {
-    final ElementManipulator<PsiElement> manipulator = getManipulator(element);
-    LOG.assertTrue(manipulator != null, element.getClass().getName());
+    final ElementManipulator<PsiElement> manipulator = getNotNullManipulator(element);
     return manipulator.getRangeInElement(element).getStartOffset();
   }
 
+  private static <T extends PsiElement> ElementManipulator<T> getNotNullManipulator(T element) {
+    final ElementManipulator<T> manipulator = getManipulator(element);
+    LOG.assertTrue(manipulator != null, element.getClass().getName());
+    return manipulator;
+  }
+
   public static TextRange getValueTextRange(final PsiElement element) {
     final ElementManipulator<PsiElement> manipulator = getManipulator(element);
     return manipulator == null ? TextRange.from(0, element.getTextLength()) : manipulator.getRangeInElement(element);
@@ -62,4 +68,9 @@ public class ElementManipulators extends ClassExtension<ElementManipulator> {
 
     return valueTextRange.substring(text);
   }
+
+  public static <T extends PsiElement> T handleContentChange(T element, String text) {
+    final ElementManipulator<T> manipulator = getNotNullManipulator(element);
+    return manipulator.handleContentChange(element, text);
+  }
 }

From 5054c4a5297ca30dc5401ce7a7a14d84f4103fd0 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 15:29:35 +0400
Subject: [PATCH 260/354] diagnostics for EA-41946 - AIOOBE:
 XmlElementFactoryImpl.createXmlAttribute

---
 xml/impl/src/com/intellij/psi/XmlElementFactoryImpl.java | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/xml/impl/src/com/intellij/psi/XmlElementFactoryImpl.java b/xml/impl/src/com/intellij/psi/XmlElementFactoryImpl.java
index 77c1b5ea915b..4073bd9af471 100644
--- a/xml/impl/src/com/intellij/psi/XmlElementFactoryImpl.java
+++ b/xml/impl/src/com/intellij/psi/XmlElementFactoryImpl.java
@@ -20,6 +20,7 @@ import com.intellij.ide.highlighter.XmlFileType;
 import com.intellij.lang.ASTFactory;
 import com.intellij.lang.Language;
 import com.intellij.lang.xml.XMLLanguage;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileTypes.FileType;
 import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.project.Project;
@@ -72,7 +73,9 @@ public class XmlElementFactoryImpl extends XmlElementFactory {
                                                    XmlFileType.INSTANCE);
     XmlTag tag = document.getRootTag();
     assert tag != null;
-    return tag.getAttributes()[0];
+    XmlAttribute[] attributes = tag.getAttributes();
+    LOG.assertTrue(attributes.length == 1, tag.getText());
+    return attributes[0];
   }
 
   @NotNull
@@ -96,4 +99,6 @@ public class XmlElementFactoryImpl extends XmlElementFactory {
     assert document != null;
     return document;
   }
+
+  private final static Logger LOG = Logger.getInstance(XmlElementFactoryImpl.class);
 }

From 30de17325501a6370950c744fd4be1fbbe6306c2 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 15:28:46 +0400
Subject: [PATCH 261/354] IDEA-101547 Please add a clock in fullscreen mode!
 After-review: move initialization if ClockPanel from IdeRootpane to
 IdeFrameImpl

---
 .../src/com/intellij/openapi/wm/impl/IdeFrameImpl.java   | 9 +++++----
 .../src/com/intellij/openapi/wm/impl/IdeRootPane.java    | 2 --
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
index 034732dc5a3f..4cf38f90b3cd 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
@@ -49,10 +49,7 @@ import com.intellij.openapi.wm.WindowManager;
 import com.intellij.openapi.wm.ex.LayoutFocusTraversalPolicyExt;
 import com.intellij.openapi.wm.ex.StatusBarEx;
 import com.intellij.openapi.wm.ex.WindowManagerEx;
-import com.intellij.openapi.wm.impl.status.EncodingPanel;
-import com.intellij.openapi.wm.impl.status.InsertOverwritePanel;
-import com.intellij.openapi.wm.impl.status.PositionPanel;
-import com.intellij.openapi.wm.impl.status.ToggleReadOnlyAttributePanel;
+import com.intellij.openapi.wm.impl.status.*;
 import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeFrame;
 import com.intellij.ui.*;
 import com.intellij.ui.mac.MacMainFrameDecorator;
@@ -374,6 +371,9 @@ public class IdeFrameImpl extends JFrame implements IdeFrame, DataProvider {
       statusBar.addWidget(readOnlyAttributePanel, "after Encoding");
     }
 
+    final ClockPanel clockPanel = new ClockPanel();
+    statusBar.addWidget(clockPanel, "after " + MemoryUsagePanel.WIDGET_ID);
+
     final InsertOverwritePanel finalInsertOverwritePanel = insertOverwritePanel;
     Disposer.register(project, new Disposable() {
       public void dispose() {
@@ -381,6 +381,7 @@ public class IdeFrameImpl extends JFrame implements IdeFrame, DataProvider {
         statusBar.removeWidget(positionPanel.ID());
         statusBar.removeWidget(notificationArea.ID());
         statusBar.removeWidget(readOnlyAttributePanel.ID());
+        statusBar.removeWidget(clockPanel.ID());
         if (finalInsertOverwritePanel != null) statusBar.removeWidget(finalInsertOverwritePanel.ID());
 
         ((StatusBarEx)statusBar).removeCustomIndicationComponents();
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
index bcde70075ada..45b4782c11dc 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeRootPane.java
@@ -35,7 +35,6 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.wm.*;
-import com.intellij.openapi.wm.impl.status.ClockPanel;
 import com.intellij.openapi.wm.impl.status.IdeStatusBarImpl;
 import com.intellij.openapi.wm.impl.status.MemoryUsagePanel;
 import com.intellij.ui.JBColor;
@@ -257,7 +256,6 @@ public class IdeRootPane extends JRootPane implements UISettingsListener {
     }
 
     myStatusBar.addWidget(myMemoryWidget);
-    myStatusBar.addWidget(new ClockPanel(), "after " + MemoryUsagePanel.WIDGET_ID);
     myStatusBar.addWidget(new IdeMessagePanel(MessagePool.getInstance()), "before " + MemoryUsagePanel.WIDGET_ID);
 
     setMemoryIndicatorVisible(myUISettings.SHOW_MEMORY_INDICATOR);

From 7e5de1125ad957b97eec0ebab6d979c59ea3e101 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 15:36:46 +0400
Subject: [PATCH 262/354] cleanup

---
 .../src/com/intellij/ide/wizard/AbstractWizard.java         | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/ide/wizard/AbstractWizard.java b/platform/platform-api/src/com/intellij/ide/wizard/AbstractWizard.java
index 2dafd653b7fa..cd0ff214d453 100644
--- a/platform/platform-api/src/com/intellij/ide/wizard/AbstractWizard.java
+++ b/platform/platform-api/src/com/intellij/ide/wizard/AbstractWizard.java
@@ -361,7 +361,7 @@ public abstract class AbstractWizard<T extends Step> extends DialogWrapper {
     // Commit data of current step
     final Step currentStep = mySteps.get(myCurrentStep);
     LOG.assertTrue(currentStep != null);
-    LOG.assertTrue(!isLastStep());
+    LOG.assertTrue(!isLastStep(), "steps: " + mySteps + " current: " + currentStep);
     try {
       currentStep._commit(false);
     }
@@ -522,8 +522,4 @@ public abstract class AbstractWizard<T extends Step> extends DialogWrapper {
   @Nullable
   @NonNls
   protected abstract String getHelpID();
-
-  protected boolean isCurrentStep(final T step) {
-    return step != null && getCurrentStepComponent() == step.getComponent();
-  }
 }

From 200a3dc9ad320649923abbde391d1e4349c6d796 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 15:39:24 +0400
Subject: [PATCH 263/354] diagnostics for EA-44279 - assert:
 AnchorReference.resolve

---
 xml/impl/src/com/intellij/xml/util/AnchorReference.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xml/impl/src/com/intellij/xml/util/AnchorReference.java b/xml/impl/src/com/intellij/xml/util/AnchorReference.java
index 5bae0f65d68e..def10cfa8217 100644
--- a/xml/impl/src/com/intellij/xml/util/AnchorReference.java
+++ b/xml/impl/src/com/intellij/xml/util/AnchorReference.java
@@ -87,7 +87,7 @@ public class AnchorReference implements PsiReference, EmptyResolveMessageProvide
         attribute = tag.getAttribute("usemap");
       }
 
-      assert attribute != null;
+      assert attribute != null: tag.getText();
       return attribute.getValueElement();
     }
 

From f21285e673e741627d523f80c0a381b79fea7a5e Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 13:06:20 +0100
Subject: [PATCH 264/354] exceptions while editing file in editor

---
 .../ide/diff/VirtualFileDiffElement.java         | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/ide/diff/VirtualFileDiffElement.java b/platform/platform-impl/src/com/intellij/ide/diff/VirtualFileDiffElement.java
index d1247fb21d7d..8d80ff89e4f5 100644
--- a/platform/platform-impl/src/com/intellij/ide/diff/VirtualFileDiffElement.java
+++ b/platform/platform-impl/src/com/intellij/ide/diff/VirtualFileDiffElement.java
@@ -19,7 +19,7 @@ import com.intellij.ide.presentation.VirtualFilePresentation;
 import com.intellij.ide.util.PropertiesComponent;
 import com.intellij.openapi.actionSystem.DataProvider;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
-import com.intellij.openapi.application.ex.ApplicationManagerEx;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diff.DiffRequest;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.fileChooser.FileChooser;
@@ -34,6 +34,7 @@ import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.PlatformIcons;
+import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -278,12 +279,17 @@ public class VirtualFileDiffElement extends DiffElement<VirtualFile> {
       }
 
       if (!docsToSave.isEmpty()) {
-        ApplicationManagerEx.getApplicationEx().runEdtSafeAction(new Runnable() {
+        UIUtil.invokeAndWaitIfNeeded(new Runnable() {
           @Override
           public void run() {
-            for (Document document : docsToSave) {
-              manager.saveDocument(document);
-            }
+            ApplicationManager.getApplication().runWriteAction(new Runnable() {
+              @Override
+              public void run() {
+                for (Document document : docsToSave) {
+                  manager.saveDocument(document);
+                }
+              }
+            });
           }
         });
       }

From deafc829828ba938af8a233d4a08abf8374ff19f Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 16:25:03 +0400
Subject: [PATCH 265/354] EA-43374 - assert: XmlTagImpl$.runInner

---
 .../codeInsight/completion/ExtendedTagInsertHandler.java        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/completion/ExtendedTagInsertHandler.java b/xml/impl/src/com/intellij/codeInsight/completion/ExtendedTagInsertHandler.java
index 644dcb93a2cd..7d990565655f 100644
--- a/xml/impl/src/com/intellij/codeInsight/completion/ExtendedTagInsertHandler.java
+++ b/xml/impl/src/com/intellij/codeInsight/completion/ExtendedTagInsertHandler.java
@@ -155,7 +155,7 @@ public class ExtendedTagInsertHandler extends XmlTagInsertHandler {
     final PsiElement tag = element.getParent();
     if (tag instanceof XmlTag) {
       final String prefix = ((XmlTag)tag).getNamespacePrefix();
-      if (!prefix.equals(namespacePrefix)) {
+      if (!prefix.equals(namespacePrefix) && StringUtil.isNotEmpty(namespacePrefix)) {
         final String name = namespacePrefix + ":" + ((XmlTag)tag).getLocalName();
         try {
           ((XmlTag)tag).setName(name);

From 95f8e79ab8f1a215821b86cec52e1e4cdba5b6be Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Wed, 27 Feb 2013 16:04:22 +0400
Subject: [PATCH 266/354] Rename method

According to a review comment CR-IC-84
---
 .../src/com/intellij/ui/EditorTextFieldProviderImpl.java      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/ui/EditorTextFieldProviderImpl.java b/platform/lang-impl/src/com/intellij/ui/EditorTextFieldProviderImpl.java
index b92d780e7970..1bf409178e7a 100644
--- a/platform/lang-impl/src/com/intellij/ui/EditorTextFieldProviderImpl.java
+++ b/platform/lang-impl/src/com/intellij/ui/EditorTextFieldProviderImpl.java
@@ -94,11 +94,11 @@ public class EditorTextFieldProviderImpl implements EditorTextFieldProvider {
       EditorSettings settings = ex.getSettings();
       settings.setAdditionalColumnsCount(3);
       settings.setVirtualSpace(false);
-      applyFeatures(ex);
+      applyCustomizations(ex);
       return ex;
     }
     
-    private void applyFeatures(@NotNull EditorEx editor) {
+    private void applyCustomizations(@NotNull EditorEx editor) {
       for (EditorCustomization customization : myCustomizations) {
         customization.customize(editor);
       }

From 6070c4c285871998568ee6d2f7bbb23403a12d76 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Wed, 27 Feb 2013 16:07:37 +0400
Subject: [PATCH 267/354] add javadoc statement

---
 .../src/com/intellij/ui/EditorTextFieldProvider.java            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/ui/EditorTextFieldProvider.java b/platform/platform-impl/src/com/intellij/ui/EditorTextFieldProvider.java
index 3bf5cecf9b74..a67ed714b295 100644
--- a/platform/platform-impl/src/com/intellij/ui/EditorTextFieldProvider.java
+++ b/platform/platform-impl/src/com/intellij/ui/EditorTextFieldProvider.java
@@ -32,7 +32,7 @@ public interface EditorTextFieldProvider {
    *
    * @param language   target language used by document that will be displayed by returned editor
    * @param project    target project
-   * @return
+   * @return {@link EditorTextField} with specified customizations applied to its editor.
    */
   @NotNull
   EditorTextField getEditorField(@NotNull Language language, @NotNull  Project project, @NotNull Iterable<EditorCustomization> features);

From bf343ccd4014660644bbe0721f61910976697196 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Wed, 27 Feb 2013 16:09:19 +0400
Subject: [PATCH 268/354] new HashSet() -> ContainerUtil.newHashSet

According to a review comment in CR-IC-84.
---
 .../openapi/vcs/changes/ui/NewEditChangelistPanel.java        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/NewEditChangelistPanel.java b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/NewEditChangelistPanel.java
index 58add2e8a032..1fa2184c734c 100644
--- a/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/NewEditChangelistPanel.java
+++ b/platform/vcs-impl/src/com/intellij/openapi/vcs/changes/ui/NewEditChangelistPanel.java
@@ -28,10 +28,10 @@ import com.intellij.openapi.vcs.changes.LocalChangeList;
 import com.intellij.spellchecker.ui.SpellCheckingEditorCustomization;
 import com.intellij.ui.*;
 import com.intellij.util.Consumer;
+import com.intellij.util.containers.ContainerUtil;
 
 import javax.swing.*;
 import java.awt.*;
-import java.util.HashSet;
 import java.util.Set;
 
 public abstract class NewEditChangelistPanel extends JPanel {
@@ -163,7 +163,7 @@ public abstract class NewEditChangelistPanel extends JPanel {
     final EditorTextFieldProvider service = ServiceManager.getService(project, EditorTextFieldProvider.class);
     final EditorTextField editorField;
 
-    final Set<EditorCustomization> editorFeatures = new HashSet<EditorCustomization>();
+    final Set<EditorCustomization> editorFeatures = ContainerUtil.newHashSet();
     editorFeatures.add(SpellCheckingEditorCustomization.ENABLED);
 
     if (defaultLines == 1) {

From 955018d9d98fd6e2b1114a73ab9d47a198bc66d7 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 16:40:50 +0400
Subject: [PATCH 269/354] IDEA-101547 Please add a clock in fullscreen mode!
 After-review: we add/remove clock when enter/exit full screen mode

---
 .../src/com/intellij/openapi/wm/impl/IdeFrameImpl.java |  4 ----
 .../intellij/openapi/wm/impl/WindowManagerImpl.java    |  7 +++++++
 .../intellij/openapi/wm/impl/status/ClockPanel.java    | 10 ----------
 3 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
index 4cf38f90b3cd..492ebc9aacef 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeFrameImpl.java
@@ -371,9 +371,6 @@ public class IdeFrameImpl extends JFrame implements IdeFrame, DataProvider {
       statusBar.addWidget(readOnlyAttributePanel, "after Encoding");
     }
 
-    final ClockPanel clockPanel = new ClockPanel();
-    statusBar.addWidget(clockPanel, "after " + MemoryUsagePanel.WIDGET_ID);
-
     final InsertOverwritePanel finalInsertOverwritePanel = insertOverwritePanel;
     Disposer.register(project, new Disposable() {
       public void dispose() {
@@ -381,7 +378,6 @@ public class IdeFrameImpl extends JFrame implements IdeFrame, DataProvider {
         statusBar.removeWidget(positionPanel.ID());
         statusBar.removeWidget(notificationArea.ID());
         statusBar.removeWidget(readOnlyAttributePanel.ID());
-        statusBar.removeWidget(clockPanel.ID());
         if (finalInsertOverwritePanel != null) statusBar.removeWidget(finalInsertOverwritePanel.ID());
 
         ((StatusBarEx)statusBar).removeCustomIndicationComponents();
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
index 3f07ae68d39a..e560f4d41a7c 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
@@ -35,10 +35,13 @@ import com.intellij.openapi.ui.popup.JBPopup;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.NamedJDOMExternalizable;
 import com.intellij.openapi.util.SystemInfo;
+import com.intellij.openapi.util.registry.Registry;
 import com.intellij.openapi.wm.IdeFrame;
 import com.intellij.openapi.wm.StatusBar;
 import com.intellij.openapi.wm.WindowManagerListener;
 import com.intellij.openapi.wm.ex.WindowManagerEx;
+import com.intellij.openapi.wm.impl.status.ClockPanel;
+import com.intellij.openapi.wm.impl.status.MemoryUsagePanel;
 import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeFrame;
 import com.intellij.ui.ScreenUtil;
 import com.intellij.util.Alarm;
@@ -847,12 +850,16 @@ public final class WindowManagerImpl extends WindowManagerEx implements Applicat
         finally {
           if (fullScreen) {
             frame.setBounds(device.getDefaultConfiguration().getBounds());
+            if (!Registry.is("ui.no.bangs.and.whistles", false)) {
+              frame.getStatusBar().addWidget(new ClockPanel(), "before " + MemoryUsagePanel.WIDGET_ID);
+            }
           }
           else {
             Object o = frame.getRootPane().getClientProperty("oldBounds");
             if (o instanceof Rectangle) {
               frame.setBounds((Rectangle)o);
             }
+            frame.getStatusBar().removeWidget(ClockPanel.WIDGET_ID);
           }
           frame.setVisible(true);
           frame.getRootPane().putClientProperty(ScreenUtil.DISPOSE_TEMPORARY, null);
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
index fc663f8692cd..1c1bdecea555 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -16,9 +16,7 @@
 package com.intellij.openapi.wm.impl.status;
 
 import com.intellij.openapi.wm.CustomStatusBarWidget;
-import com.intellij.openapi.wm.IdeFrame;
 import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.impl.IdeFrameImpl;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -53,7 +51,6 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget {
   protected final Calendar myCalendar;
   private final Timer myTimer;
   private final boolean is24Hours;
-  private IdeFrameImpl myIdeFrame;
 
   public ClockPanel() {
     myCalendar = getInstance();
@@ -74,21 +71,14 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget {
 
   @Override
   public void install(@NotNull StatusBar statusBar) {
-    IdeFrame frame = statusBar.getFrame();
-    myIdeFrame = frame instanceof IdeFrameImpl ? (IdeFrameImpl)frame : null;
     myTimer.start();
   }
 
   @Override
   public void dispose() {
     myTimer.stop();
-    myIdeFrame = null;
   }
 
-  @Override
-  public boolean isVisible() {
-    return myIdeFrame != null && myIdeFrame.isInFullScreen();
-  }
 
   @Override
   public JComponent getComponent() {

From 3deb3506ded5fb4b5cbcd8ff3190344f1360a2ef Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 16:49:52 +0400
Subject: [PATCH 270/354] add documentation comments

---
 .../com/intellij/openapi/wm/impl/status/ClockPanel.java  | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
index 1c1bdecea555..acc41de7b189 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -38,6 +38,15 @@ import static java.util.Calendar.*;
  */
 public class ClockPanel extends JComponent implements CustomStatusBarWidget {
   @NonNls public static final String WIDGET_ID = "Clock";
+  //              top
+  //              ---
+  //    top-left |   | top-right
+  //             |   |
+  //      middle  ---
+  // bottom-left |   | bottom-right
+  //             |   |
+  //              ---
+  //            bottom
   private static final int[] MASK = new int[]{
     1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9,//top
     1 << 0 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9,//top-left

From a0c1b45505f48a5a77f73c84e1d55b56e97ded91 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 13:50:09 +0100
Subject: [PATCH 271/354] some OpenTHashSet doc

---
 .../util/src/com/intellij/util/containers/OpenTHashSet.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/platform/util/src/com/intellij/util/containers/OpenTHashSet.java b/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
index 40e5a7d1ab31..9f201b6c7f05 100644
--- a/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
+++ b/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
@@ -22,6 +22,9 @@ import org.jetbrains.annotations.Nullable;
 import java.util.Collection;
 
 /**
+ * Makes some THashSet methods open to the public.
+ * Adds {@link #get(Object)} method useful to intern objects.
+ *
 * @author gregsh
 */
 public class OpenTHashSet<T> extends THashSet<T> {
@@ -66,6 +69,9 @@ public class OpenTHashSet<T> extends THashSet<T> {
     return (T)_set[index];
   }
 
+  /**
+   * Returns an element of this set equal to the give one. Can be used for interning objects to save memory.
+   */
   @Nullable
   public T get(final T obj) {
     final int index = index(obj);

From 149009eb41388a80b77d5d488041f1e81c2090b5 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 14:02:14 +0100
Subject: [PATCH 272/354] IDEA-101843 Seems "Super Method" action can be dumb
 aware

---
 .../navigation/actions/GotoSuperAction.java          | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
index 13f75d480460..f74f9b7ea493 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
@@ -22,6 +22,9 @@ import com.intellij.lang.CodeInsightActions;
 import com.intellij.lang.Language;
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.DumbService;
+import com.intellij.openapi.project.IndexNotReadyException;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
@@ -29,7 +32,7 @@ import com.intellij.psi.util.PsiUtilBase;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsightActionHandler {
+public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsightActionHandler, DumbAware {
 
   @NonNls public static final String FEATURE_ID = "navigation.goto.super";
 
@@ -48,7 +51,12 @@ public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsigh
 
     final CodeInsightActionHandler codeInsightActionHandler = CodeInsightActions.GOTO_SUPER.forLanguage(language);
     if (codeInsightActionHandler != null) {
-      codeInsightActionHandler.invoke(project, editor, file);
+      try {
+        codeInsightActionHandler.invoke(project, editor, file);
+      }
+      catch (IndexNotReadyException e) {
+        DumbService.getInstance(project).showDumbModeNotification("Goto Super action is not available during indexing");
+      }
     }
   }
 

From ee30e3c80abd2888eb949dea920f705ca3201848 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 14:57:51 +0400
Subject: [PATCH 273/354] cleanup

---
 .../convertToJava/ExpressionGenerator.java    | 25 +++++++------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ExpressionGenerator.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ExpressionGenerator.java
index 9288368d2486..3feab9d73313 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ExpressionGenerator.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ExpressionGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -21,7 +21,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.light.LightElement;
-import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.ArrayUtil;
@@ -455,14 +454,11 @@ public class ExpressionGenerator extends Generator {
           getRValue(expression)
         };
         GroovyResolveResult[] candidates = type != null
-                                           ? ResolveUtil
-                                             .getMethodCandidates(type, "setProperty", expression, args[0].getType(), args[1].getType())
+                                           ? ResolveUtil.getMethodCandidates(type, "setProperty", expression, args[0].getType(), args[1].getType())
                                            : GroovyResolveResult.EMPTY_ARRAY;
-        final PsiElement method = PsiImplUtil.extractUniqueElement(candidates);
-
-        if (method instanceof PsiMethod) {
-          writeAssignmentWithSetter(qualifier, (PsiMethod)method, args, GrNamedArgument.EMPTY_ARRAY, EMPTY_ARRAY, PsiSubstitutor.EMPTY,
-                                    expression);
+        final PsiMethod method = PsiImplUtil.extractUniqueElement(candidates);
+        if (method != null) {
+          writeAssignmentWithSetter(qualifier, method, args, GrNamedArgument.EMPTY_ARRAY, EMPTY_ARRAY, PsiSubstitutor.EMPTY, expression);
           return;
         }
       }
@@ -1017,10 +1013,9 @@ public class ExpressionGenerator extends Generator {
       }
       else {
         //unresolved reference
-        final String refName = referenceName;
-        if (refName != null) {
+        if (referenceName != null) {
           if (PsiUtil.isAccessedForWriting(referenceExpression)) {
-            builder.append(refName);
+            builder.append(referenceName);
           }
           else {
             PsiType stringType = PsiType.getJavaLangString(referenceExpression.getManager(), referenceExpression.getResolveScope());
@@ -1031,10 +1026,10 @@ public class ExpressionGenerator extends Generator {
                                                : GroovyResolveResult.EMPTY_ARRAY;
             final PsiElement method = PsiImplUtil.extractUniqueElement(candidates);
             if (method != null) {
-              builder.append("getProperty(\"").append(refName).append("\")");
+              builder.append("getProperty(\"").append(referenceName).append("\")");
             }
             else {
-              builder.append(refName);
+              builder.append(referenceName);
             }
           }
         }
@@ -1256,8 +1251,6 @@ public class ExpressionGenerator extends Generator {
       }
     }
     final PsiType[] argTypes = PsiUtil.getArgumentTypes(argList);
-    final PsiManager manager = expression.getManager();
-    final GlobalSearchScope resolveScope = expression.getResolveScope();
 
     final GrExpression[] exprArgs = argList.getExpressionArguments();
     final GrNamedArgument[] namedArgs = argList.getNamedArguments();

From ea917a3db4a2fe6407c58130c8ec4cd5f4849fea Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 17:08:01 +0400
Subject: [PATCH 274/354] fix surrounder tests

---
 .../surroundWith/SurrounderOrderTest.groovy   | 35 +++++++++++++------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurrounderOrderTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurrounderOrderTest.groovy
index 76c884173a6f..c6df083b3e36 100644
--- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurrounderOrderTest.groovy
+++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/surroundWith/SurrounderOrderTest.groovy
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2013 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,10 +15,10 @@
  */
 package org.jetbrains.plugins.groovy.lang.surroundWith
 
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.codeInsight.generation.surroundWith.SurroundWithHandler
 import com.intellij.openapi.actionSystem.Separator
 import com.intellij.openapi.application.WriteAction
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 
 /**
  * @author peter
@@ -28,11 +28,16 @@ class SurrounderOrderTest extends LightCodeInsightFixtureTestCase {
   public void testStatementSurrounders() {
     def names = getSurrounders("<selection>println a</selection>")
     assertOrderedEquals names,
-                        "if", "if / else", "while",
+                        "if", "if / else",
+                        "while",
                         "{ -> ... }.call()",
-                        "for", "try / catch", "try / finally", "try / catch / finally",
+                        "for", "try / catch",
+                        "try / finally",
+                        "try / catch / finally",
                         "shouldFail () {...}",
-                        "(expr)", "((Type) expr)",
+                        "(expr)",
+                        "!(expr)",
+                        "((Type) expr)",
                         "with () {...}"
   }
 
@@ -61,19 +66,29 @@ println c /*also important */
 
   public void testInnerExpressionSurrounders() {
     def names = getSurrounders("boolean a; println <selection>a</selection>")
-    assertOrderedEquals names, "(expr)", "((Type) expr)"
+    assertOrderedEquals names, "(expr)", "!(expr)", "((Type) expr)"
   }
 
   public void testOuterExpressionSurrounders() {
     def names = getSurrounders("boolean a; <selection>a</selection>")
     assertOrderedEquals names,
-                        "if", "if / else", "while",
+                        "if",
+                        "if / else",
+                        "while",
                         "{ -> ... }.call()",
-                        "for", "try / catch", "try / finally", "try / catch / finally",
+                        "for",
+                        "try / catch",
+                        "try / finally",
+                        "try / catch / finally",
                         "shouldFail () {...}",
-                        "(expr)", "((Type) expr)",
+                        "(expr)",
+                        "!(expr)",
+                        "((Type) expr)",
                         "with () {...}",
-                        "if (expr)", "if (expr) / else", "while (expr)", "with (expr)"
+                        "if (expr)",
+                        "if (expr) / else",
+                        "while (expr)",
+                        "with (expr)"
   }
 
   private List<String> getSurrounders(final String fileText) {

From 72f87c065ef7cdede9ef5908ac3cfbe795b167e0 Mon Sep 17 00:00:00 2001
From: Max Medvedev <maxim.medvedev@jetbrains.com>
Date: Wed, 27 Feb 2013 17:08:16 +0400
Subject: [PATCH 275/354] fix typo

---
 .../groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
index 96d4e0c41b4a..ff4eeb01b68a 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyPsiElementFactoryImpl.java
@@ -421,7 +421,7 @@ public class GroovyPsiElementFactoryImpl extends GroovyPsiElementFactory {
   }
 
   public PsiElement createModifierFromText(String name) {
-    final GroovyFileBase file = createGroovyFileChecked(name + "foo() {}");
+    final GroovyFileBase file = createGroovyFileChecked(name + " foo() {}");
     final GrTopLevelDefinition[] definitions = file.getTopLevelDefinitions();
     if (definitions.length != 1) throw new IncorrectOperationException(name);
     return definitions[0].getFirstChild().getFirstChild();

From 9b729351c07040304c54edd962281bf0f9fef02a Mon Sep 17 00:00:00 2001
From: Dmitry Jemerov <yole@jetbrains.com>
Date: Wed, 27 Feb 2013 13:43:04 +0100
Subject: [PATCH 276/354] API to allow SDK type to check if the SDK path is
 valid, so that remote SDKs can be highlighted as valid even if they don't
 have a valid home directory (required for PY-8079)

---
 .../roots/ui/OrderEntryAppearanceServiceImpl.java   |  6 +++---
 .../com/intellij/openapi/projectRoots/SdkType.java  | 13 +++++++++++++
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/OrderEntryAppearanceServiceImpl.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/OrderEntryAppearanceServiceImpl.java
index 154a03534105..7ce323537d05 100644
--- a/java/idea-ui/src/com/intellij/openapi/roots/ui/OrderEntryAppearanceServiceImpl.java
+++ b/java/idea-ui/src/com/intellij/openapi/roots/ui/OrderEntryAppearanceServiceImpl.java
@@ -122,9 +122,9 @@ public class OrderEntryAppearanceServiceImpl extends OrderEntryAppearanceService
 
     String name = jdk.getName();
     CompositeAppearance appearance = new CompositeAppearance();
-    appearance.setIcon(((SdkType) jdk.getSdkType()).getIcon());
-    VirtualFile homeDirectory = jdk.getHomeDirectory();
-    SimpleTextAttributes attributes = getTextAttributes(homeDirectory != null && homeDirectory.isValid(), selected);
+    SdkType sdkType = (SdkType)jdk.getSdkType();
+    appearance.setIcon(sdkType.getIcon());
+    SimpleTextAttributes attributes = getTextAttributes(sdkType.sdkHasValidPath(jdk), selected);
     CompositeAppearance.DequeEnd ending = appearance.getEnding();
     ending.addText(name, attributes);
 
diff --git a/platform/lang-api/src/com/intellij/openapi/projectRoots/SdkType.java b/platform/lang-api/src/com/intellij/openapi/projectRoots/SdkType.java
index 31072561f21f..32f9a1673395 100644
--- a/platform/lang-api/src/com/intellij/openapi/projectRoots/SdkType.java
+++ b/platform/lang-api/src/com/intellij/openapi/projectRoots/SdkType.java
@@ -224,4 +224,17 @@ public abstract class SdkType implements SdkTypeId {
    */
   public void showCustomCreateUI(SdkModel sdkModel, JComponent parentComponent, Consumer<Sdk> sdkCreatedCallback) {
   }
+
+  /**
+   * Checks if the home directory of the specified SDK is valid. By default, checks that the directory points to a valid local
+   * path. Can be overridden for remote SDKs.
+   *
+   * @param sdk the SDK to validate the path for.
+   * @return true if the home path is valid, false otherwise.
+   * @since 12.1
+   */
+  public boolean sdkHasValidPath(@NotNull Sdk sdk) {
+    VirtualFile homeDir = sdk.getHomeDirectory();
+    return homeDir != null && homeDir.isValid();
+  }
 }

From b2f7501579a25fd780beedb47656eee7a7033f42 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Wed, 27 Feb 2013 17:19:57 +0400
Subject: [PATCH 277/354] IDEA-101776 Gradle: Avoid ide hang on auto-import

Don't call to LibraryImpl.getFiles() as that takes too much time for libraries with huge number of jars
---
 .../gradle/ui/GradleProjectStructureNodeComparator.java        | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/ui/GradleProjectStructureNodeComparator.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/ui/GradleProjectStructureNodeComparator.java
index 021b790398d2..1981199cf4ea 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/ui/GradleProjectStructureNodeComparator.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/ui/GradleProjectStructureNodeComparator.java
@@ -77,6 +77,9 @@ public class GradleProjectStructureNodeComparator implements Comparator<GradlePr
     if (id.getType() == GradleEntityType.SYNTHETIC) {
       return SYNTHETIC_WEIGHT;
     }
+    else if (id.getType() == GradleEntityType.JAR) {
+      return JAR_WEIGHT;
+    }
     Object entity = id.mapToEntity(myContext);
     if (entity instanceof AbstractGradleCompositeEntity) {
       entity = ((AbstractGradleCompositeEntity)entity).getIdeEntity();

From f376e061c3cb5fcdc57aba29a187b03645e4ec17 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 14:23:49 +0100
Subject: [PATCH 278/354] IDEA-101989 Darcula: red color in editor tab is too
 bright

---
 .../com/intellij/openapi/fileEditor/impl/EditorsSplitters.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
index cb82d467761b..2d99cfbe5443 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/EditorsSplitters.java
@@ -461,7 +461,7 @@ public class EditorsSplitters extends JBPanel {
       final int index = window.findEditorIndex(window.findFileComposite(file));
       LOG.assertTrue(index != -1);
       window.setForegroundAt(index, getManager().getFileColor(file));
-      window.setWaveColor(index, getManager().isProblem(file) ? Color.red : null);
+      window.setWaveColor(index, getManager().isProblem(file) ? JBColor.red : null);
     }
   }
 

From 8c1de3f8eed7ce9518b5f73819c087b839cf4993 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 17:29:35 +0400
Subject: [PATCH 279/354] EA-39139 - CCE: DomServiceImpl.calcXmlFileHeader

---
 .../src/com/intellij/util/xml/impl/DomServiceImpl.java      | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/xml/dom-impl/src/com/intellij/util/xml/impl/DomServiceImpl.java b/xml/dom-impl/src/com/intellij/util/xml/impl/DomServiceImpl.java
index 00c13e716610..b2c5ca5915ce 100644
--- a/xml/dom-impl/src/com/intellij/util/xml/impl/DomServiceImpl.java
+++ b/xml/dom-impl/src/com/intellij/util/xml/impl/DomServiceImpl.java
@@ -31,6 +31,7 @@ import com.intellij.psi.PsiManager;
 import com.intellij.psi.impl.PsiFileEx;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.stubs.ObjectStubTree;
+import com.intellij.psi.stubs.Stub;
 import com.intellij.psi.stubs.StubTreeLoader;
 import com.intellij.psi.util.CachedValue;
 import com.intellij.psi.util.CachedValueProvider;
@@ -76,7 +77,10 @@ public class DomServiceImpl extends DomService {
       if (virtualFile instanceof VirtualFileWithId) {
         ObjectStubTree tree = StubTreeLoader.getInstance().readFromVFile(file.getProject(), virtualFile);
         if (tree != null) {
-          return ((FileStub)tree.getRoot()).getHeader();
+          Stub root = tree.getRoot();
+          if (root instanceof FileStub) {
+            return ((FileStub)root).getHeader();
+          }
         }
       }
     }

From 3f989209b65ae79dcae4236ac6d0875dfc376176 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 17:44:18 +0400
Subject: [PATCH 280/354] Don't show clock in Mac OS

---
 .../src/com/intellij/openapi/wm/impl/WindowManagerImpl.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
index e560f4d41a7c..c96f5501a93a 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/WindowManagerImpl.java
@@ -850,7 +850,7 @@ public final class WindowManagerImpl extends WindowManagerEx implements Applicat
         finally {
           if (fullScreen) {
             frame.setBounds(device.getDefaultConfiguration().getBounds());
-            if (!Registry.is("ui.no.bangs.and.whistles", false)) {
+            if (!Registry.is("ui.no.bangs.and.whistles", false) && !SystemInfo.isMac) {
               frame.getStatusBar().addWidget(new ClockPanel(), "before " + MemoryUsagePanel.WIDGET_ID);
             }
           }

From 1b895f5ac6e258a67b16ce998fb1e92270e80144 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Wed, 27 Feb 2013 17:56:45 +0400
Subject: [PATCH 281/354] Fix a misprint

---
 .../util/src/com/intellij/util/containers/OpenTHashSet.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/util/src/com/intellij/util/containers/OpenTHashSet.java b/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
index 9f201b6c7f05..f2aa453a1439 100644
--- a/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
+++ b/platform/util/src/com/intellij/util/containers/OpenTHashSet.java
@@ -70,7 +70,7 @@ public class OpenTHashSet<T> extends THashSet<T> {
   }
 
   /**
-   * Returns an element of this set equal to the give one. Can be used for interning objects to save memory.
+   * Returns an element of this set equal to the given one. Can be used for interning objects to save memory.
    */
   @Nullable
   public T get(final T obj) {

From 3b8b7b84cb54cab6ff9c89ddcab90d771844409d Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 14:58:36 +0100
Subject: [PATCH 282/354] commitDocument exceptions shouldn't fail the entire
 save (IDEA-101980)

---
 .../src/com/intellij/psi/impl/PsiDocumentManagerImpl.java  | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
index 05a59804171a..93a2277cc51d 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
@@ -819,7 +819,12 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec
     // Ensure all documents are committed on save so file content dependent indices, that use PSI to build have consistent content.
     UIUtil.invokeLaterIfNeeded(new Runnable() {
       public void run() {
-        commitAllDocuments();
+        try {
+          commitAllDocuments();
+        }
+        catch (Exception e) {
+          LOG.error(e);
+        }
       }
     });
   }

From a6f7a0f1ac151d1d23c06eccb5784d4c228223f5 Mon Sep 17 00:00:00 2001
From: Eugene Zhuravlev <jeka@intellij.com>
Date: Wed, 27 Feb 2013 14:44:09 +0100
Subject: [PATCH 283/354] moving javadocs to interface

---
 .../intellij/util/indexing/FileBasedIndex.java    | 15 +++++++++++++++
 .../util/indexing/FileBasedIndexImpl.java         | 11 -----------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/platform/indexing-api/src/com/intellij/util/indexing/FileBasedIndex.java b/platform/indexing-api/src/com/intellij/util/indexing/FileBasedIndex.java
index 29647eccbbfd..6851c99c954e 100644
--- a/platform/indexing-api/src/com/intellij/util/indexing/FileBasedIndex.java
+++ b/platform/indexing-api/src/com/intellij/util/indexing/FileBasedIndex.java
@@ -74,6 +74,9 @@ public abstract class FileBasedIndex implements BaseComponent {
                                                                     @NotNull K dataKey,
                                                                     @NotNull GlobalSearchScope filter);
 
+  /**
+   * @return false if ValueProcessor.process() returned false; true otherwise or if ValueProcessor was not called at all
+   */
   public abstract <K, V> boolean processValues(@NotNull ID<K, V> indexId,
                                                @NotNull K dataKey,
                                                @Nullable VirtualFile inFile,
@@ -86,9 +89,17 @@ public abstract class FileBasedIndex implements BaseComponent {
                                                                @Nullable Condition<V> valueChecker,
                                                                @NotNull Processor<VirtualFile> processor);
 
+  /**
+   * @param project it is guaranteed to return data which is up-to-date withing the project
+   *                Keys obtained from the files which do not belong to the project specified may not be up-to-date or even exist
+   */
   @NotNull
   public abstract <K> Collection<K> getAllKeys(@NotNull ID<K, ?> indexId, @NotNull Project project);
 
+  /**
+   * DO NOT CALL DIRECTLY IN CLIENT CODE
+   * The method is internal to indexing engine end is called internally. The method is public due to implementation details
+   */
   public abstract <K> void ensureUpToDate(@NotNull ID<K, ?> indexId, @Nullable Project project, @Nullable GlobalSearchScope filter);
 
   public abstract void requestRebuild(ID<?, ?> indexId, Throwable throwable);
@@ -104,6 +115,10 @@ public abstract class FileBasedIndex implements BaseComponent {
                                                  @NotNull Processor<VirtualFile> processor,
                                                  @NotNull GlobalSearchScope filter);
 
+  /**
+   * @param project it is guaranteed to return data which is up-to-date withing the project
+   *                Keys obtained from the files which do not belong to the project specified may not be up-to-date or even exist
+   */
   public abstract <K> boolean processAllKeys(@NotNull ID<K, ?> indexId, Processor<K> processor, @Nullable Project project);
 
   public interface ValueProcessor<V> {
diff --git a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java
index 98e646369d21..b2ded8afaaea 100644
--- a/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java
+++ b/platform/lang-impl/src/com/intellij/util/indexing/FileBasedIndexImpl.java
@@ -675,10 +675,6 @@ public class FileBasedIndexImpl extends FileBasedIndex {
     }
   }
 
-  /**
-   * @param project it is guaranteed to return data which is up-to-date withing the project
-   *                Keys obtained from the files which do not belong to the project specified may not be up-to-date or even exist
-   */
   @Override
   @NotNull
   public <K> Collection<K> getAllKeys(@NotNull final ID<K, ?> indexId, @NotNull Project project) {
@@ -687,10 +683,6 @@ public class FileBasedIndexImpl extends FileBasedIndex {
     return allKeys;
   }
 
-  /**
-   * @param project it is guaranteed to return data which is up-to-date withing the project
-   *                Keys obtained from the files which do not belong to the project specified may not be up-to-date or even exist
-   */
   @Override
   public <K> boolean processAllKeys(@NotNull final ID<K, ?> indexId, Processor<K> processor, @Nullable Project project) {
     try {
@@ -867,9 +859,6 @@ public class FileBasedIndexImpl extends FileBasedIndex {
   }
 
 
-  /**
-   * @return false if ValueProcessor.process() returned false; true otherwise or if ValueProcessor was not called at all
-   */
   @Override
   public <K, V> boolean processValues(@NotNull final ID<K, V> indexId, @NotNull final K dataKey, @Nullable final VirtualFile inFile,
                                       @NotNull ValueProcessor<V> processor, @NotNull final GlobalSearchScope filter) {

From a70d203871df8f5f12cc1101b581037e725457af Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 15:49:50 +0100
Subject: [PATCH 284/354] [Johnny Clark] make condition checkers
 psi-independent, minor fixes (IDEA-35808)

---
 .../codeInsight/ConditionCheckManager.java    |  82 ++--
 .../codeInsight/ConditionChecker.java         | 398 +++++++++++++++++-
 .../codeInsight/MethodConditionCheck.java     | 395 -----------------
 .../dataFlow/ConditionCheckDialog.java        | 166 ++++----
 .../dataFlow/MethodCheckerDetailsDialog.java  | 371 +++++++++-------
 .../DataFlowInspectionTest.java               |  36 +-
 6 files changed, 761 insertions(+), 687 deletions(-)
 delete mode 100644 java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java

diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
index 92676fc2ecef..b9be30108002 100644
--- a/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionCheckManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -29,83 +29,77 @@ import java.util.List;
  *         Creation Date: 8/3/12
  */
 @State(
-  name = "IsNullIsNotNullCheckManager",
+  name = "ConditionCheckManager",
   storages = {@Storage(id = "dir", file = StoragePathMacros.PROJECT_CONFIG_DIR + "/checker.xml", scheme = StorageScheme.DIRECTORY_BASED)}
 )
 public class ConditionCheckManager implements PersistentStateComponent<ConditionCheckManager.State> {
   @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) private State state;
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.ConditionCheckManager");
 
-  private List<MethodConditionCheck> myIsNullCheckMethods = new ArrayList<MethodConditionCheck>();
-  private List<MethodConditionCheck> myIsNotNullCheckMethods = new ArrayList<MethodConditionCheck>();
+  private List<ConditionChecker> myIsNullCheckMethods = new ArrayList<ConditionChecker>();
+  private List<ConditionChecker> myIsNotNullCheckMethods = new ArrayList<ConditionChecker>();
 
-  private List<MethodConditionCheck> myAssertIsNullMethods = new ArrayList<MethodConditionCheck>();
-  private List<MethodConditionCheck> myAssertIsNotNullMethods = new ArrayList<MethodConditionCheck>();
+  private List<ConditionChecker> myAssertIsNullMethods = new ArrayList<ConditionChecker>();
+  private List<ConditionChecker> myAssertIsNotNullMethods = new ArrayList<ConditionChecker>();
 
-  private List<MethodConditionCheck> myAssertTrueMethods = new ArrayList<MethodConditionCheck>();
-  private List<MethodConditionCheck> myAssertFalseMethods = new ArrayList<MethodConditionCheck>();
-
-  private Project myProject;
-
-  public ConditionCheckManager(Project project) {
-    myProject = project;
-  }
+  private List<ConditionChecker> myAssertTrueMethods = new ArrayList<ConditionChecker>();
+  private List<ConditionChecker> myAssertFalseMethods = new ArrayList<ConditionChecker>();
 
   public static ConditionCheckManager getInstance(Project project) {
     return ServiceManager.getService(project, ConditionCheckManager.class);
   }
 
-  public void setIsNullCheckMethods(List<MethodConditionCheck> methodConditionChecks) {
+  public void setIsNullCheckMethods(List<ConditionChecker> methodConditionChecks) {
     myIsNullCheckMethods.clear();
     myIsNullCheckMethods.addAll(methodConditionChecks);
   }
 
-  public void setIsNotNullCheckMethods(List<MethodConditionCheck> methodConditionChecks) {
+  public void setIsNotNullCheckMethods(List<ConditionChecker> methodConditionChecks) {
     myIsNotNullCheckMethods.clear();
     myIsNotNullCheckMethods.addAll(methodConditionChecks);
   }
 
-  public void setAssertNullMethods(List<MethodConditionCheck> methodConditionChecks) {
+  public void setAssertIsNullMethods(List<ConditionChecker> methodConditionChecks) {
     myAssertIsNullMethods.clear();
     myAssertIsNullMethods.addAll(methodConditionChecks);
   }
 
-  public void setAssertNotNullMethods(List<MethodConditionCheck> methodConditionChecks) {
+  public void setAssertIsNotNullMethods(List<ConditionChecker> methodConditionChecks) {
     myAssertIsNotNullMethods.clear();
     myAssertIsNotNullMethods.addAll(methodConditionChecks);
   }
 
-  public void setAssertTrueMethods(List<MethodConditionCheck> psiMethodWrappers) {
+  public void setAssertTrueMethods(List<ConditionChecker> psiMethodWrappers) {
     myAssertTrueMethods.clear();
     myAssertTrueMethods.addAll(psiMethodWrappers);
   }
 
-  public void setAssertFalseMethods(List<MethodConditionCheck> psiMethodWrappers) {
+  public void setAssertFalseMethods(List<ConditionChecker> psiMethodWrappers) {
     myAssertFalseMethods.clear();
     myAssertFalseMethods.addAll(psiMethodWrappers);
   }
 
-  public List<MethodConditionCheck> getIsNullCheckMethods() {
+  public List<ConditionChecker> getIsNullCheckMethods() {
     return myIsNullCheckMethods;
   }
 
-  public List<MethodConditionCheck> getIsNotNullCheckMethods() {
+  public List<ConditionChecker> getIsNotNullCheckMethods() {
     return myIsNotNullCheckMethods;
   }
 
-  public List<MethodConditionCheck> getAssertIsNullMethods() {
+  public List<ConditionChecker> getAssertIsNullMethods() {
     return myAssertIsNullMethods;
   }
 
-  public List<MethodConditionCheck> getAssertIsNotNullMethods() {
+  public List<ConditionChecker> getAssertIsNotNullMethods() {
     return myAssertIsNotNullMethods;
   }
 
-  public List<MethodConditionCheck> getAssertFalseMethods() {
+  public List<ConditionChecker> getAssertFalseMethods() {
     return myAssertFalseMethods;
   }
 
-  public List<MethodConditionCheck> getAssertTrueMethods() {
+  public List<ConditionChecker> getAssertTrueMethods() {
     return myAssertTrueMethods;
   }
 
@@ -132,8 +126,8 @@ public class ConditionCheckManager implements PersistentStateComponent<Condition
     return state;
   }
 
-  private static void loadMethodChecksToState(List<String> listToLoadTo, List<MethodConditionCheck> listToLoadFrom) {
-    for (MethodConditionCheck checker : listToLoadFrom) {
+  private static void loadMethodChecksToState(List<String> listToLoadTo, List<ConditionChecker> listToLoadFrom) {
+    for (ConditionChecker checker : listToLoadFrom) {
       listToLoadTo.add(checker.toString());
     }
   }
@@ -149,20 +143,20 @@ public class ConditionCheckManager implements PersistentStateComponent<Condition
     loadMethods(myAssertFalseMethods, state.myAssertFalseMethods, ConditionChecker.Type.ASSERT_FALSE_METHOD);
   }
 
-  public void loadMethods(List<MethodConditionCheck> listToLoadTo, List<String> listToLoadFrom, ConditionChecker.Type type){
+  public void loadMethods(List<ConditionChecker> listToLoadTo, List<String> listToLoadFrom, ConditionChecker.Type type){
     listToLoadTo.clear();
     for (String setting : listToLoadFrom) {
       try {
-        listToLoadTo.add(new MethodConditionCheck.Builder(setting, type, myProject).build());
+        listToLoadTo.add(new ConditionChecker.FromConfigBuilder(setting, type).build());
       } catch (Exception e) {
         LOG.error("Problem occurred while attempting to load Condition Check from configuration file. " + e.getMessage());
       }
     }
   }
 
-  public static boolean isMethod(@NotNull PsiMethod psiMethod, List<MethodConditionCheck> checkers) {
-    for (MethodConditionCheck checker : checkers) {
-      if (checker.matches(psiMethod)) {
+  public static boolean isMethod(@NotNull PsiMethod psiMethod, List<ConditionChecker> checkers) {
+    for (ConditionChecker checker : checkers) {
+      if (checker.matchesPsiMethod(psiMethod)) {
         return true;
       }
     }
@@ -227,29 +221,19 @@ public class ConditionCheckManager implements PersistentStateComponent<Condition
     return methodMatches(psiMethod, paramIndex, getInstance(psiMethod.getProject()).getAssertFalseMethods());
   }
 
-  public static boolean methodMatches(PsiMethod psiMethod, List<MethodConditionCheck> checkers) {
-    for (MethodConditionCheck checker : checkers) {
-      if (checker.matches(psiMethod))
+  public static boolean methodMatches(PsiMethod psiMethod, List<ConditionChecker> checkers) {
+    for (ConditionChecker checker : checkers) {
+      if (checker.matchesPsiMethod(psiMethod))
         return true;
     }
     return false;
   }
 
-  public static boolean methodMatches(PsiMethod psiMethod, int paramIndex, List<MethodConditionCheck> checkers) {
-    for (MethodConditionCheck checker : checkers) {
-      if (checker.matches(psiMethod, paramIndex))
+  public static boolean methodMatches(PsiMethod psiMethod, int paramIndex, List<ConditionChecker> checkers) {
+    for (ConditionChecker checker : checkers) {
+      if (checker.matchesPsiMethod(psiMethod, paramIndex))
         return true;
     }
     return false;
   }
-
-  public static boolean isNullCheck(PsiMethod psiMethod) {
-    ConditionCheckManager manager = getInstance(psiMethod.getProject());
-    return isMethod(psiMethod, manager.getIsNullCheckMethods()) || isMethod(psiMethod, manager.getAssertIsNullMethods());
-  }
-
-  public static boolean isNotNullCheck(PsiMethod psiMethod) {
-    ConditionCheckManager manager = getInstance(psiMethod.getProject());
-    return isMethod(psiMethod, manager.getIsNotNullCheckMethods()) || isMethod(psiMethod, manager.getAssertIsNotNullMethods());
-  }
 }
diff --git a/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
index 3fb86a0d48b0..de3871d0e61b 100644
--- a/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
+++ b/java/java-impl/src/com/intellij/codeInsight/ConditionChecker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,20 +15,50 @@
  */
 package com.intellij.codeInsight;
 
+import com.intellij.openapi.diagnostic.*;
 import com.intellij.psi.*;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.*;
+
+import java.io.*;
+import java.util.*;
+
 
 /**
- * Interface for IsNull, IsNotNull Method Checks and Assert True/False/IsNull/IsNotNull Method Checks to be performed by the Constant Condition Inspection.
- * These Checkers allow the user to specify that the method in question performs some type of validation on the parameter passed into the method.
- * For example, if the method is defined as performing an IsNotNull Check, and variable x is passed into the method, then all code after the method call
- * will assume that x is Not Null.
+ * Used by Constant Condition Inspection to identify methods which perform some type of Validation on the parameters passed into them.
+ * For example given the following method
+ * <pre>
+ * {@code
+ *  class Foo {
+ *     static boolean validateNotNull(Object o) {
+ *       if (o == null) return false;
+ *       else return true;
+ *     }
+ *   }
+ * }
+ *
+ * The corresponding ConditionCheck would be <p/>
+ * myConditionCheckType=Type.IS_NOT_NULL_METHOD
+ * myClassName=Foo
+ * myMethodName=validateNotNull
+ * myPsiParameter=o
+ *
+ * The following block of code would produce a Inspection Warning that o is always true
+ *
+ *  <pre>
+ * {@code
+ *   if (Value.isNotNull(o)) {
+ *     if(o != null) {}
+ *   }
+ * }
+ * </pre>
  *
  * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
  *         Creation Date: 8/14/12
  */
-public interface ConditionChecker {
-  enum Type {
+public class ConditionChecker implements Serializable {
+  private final @NotNull Type myConditionCheckType;
+
+  public enum Type {
     IS_NULL_METHOD("IsNull Method"),
     IS_NOT_NULL_METHOD("IsNotNull Method"),
     ASSERT_IS_NULL_METHOD("Assert IsNull Method"),
@@ -47,11 +77,355 @@ public interface ConditionChecker {
     }
   }
 
-  boolean matches(PsiMethod psiMethod);
-  boolean matches(PsiMethod psiMethod, int paramIndex);
+  private final @NotNull String myClassName;
+  private final @NotNull String myMethodName;
+  private final @NotNull List<String> myParameterClassList;
+  private final int myCheckedParameterIndex;
+  private final String myFullName;
 
-  boolean overlaps(ConditionChecker checker);
+  private ConditionChecker(@NotNull String className,
+                           @NotNull String methodName,
+                           @NotNull List<String> parameterClassList,
+                           int checkedParameterIndex,
+                           @NotNull Type type,
+                           @NotNull String fullName) {
+    checkState(!className.isEmpty(), "Class Name is blank");
+    checkState(!methodName.isEmpty(), "Method Name is blank");
+    checkState(!parameterClassList.isEmpty(), "Parameter Class List is empty");
+    checkState(checkedParameterIndex >= 0, "CheckedParameterIndex must be greater than or equal to zero");
+    checkState(parameterClassList.size() >= checkedParameterIndex, "CheckedParameterIndex is greater than Parameter Class List's size");
+    checkState(!fullName.isEmpty(), "Method Name is blank");
+
+    myConditionCheckType = type;
+    myClassName = className;
+    myMethodName = methodName;
+    myParameterClassList = parameterClassList;
+    myCheckedParameterIndex = checkedParameterIndex;
+    myFullName = fullName;
+  }
+
+  private static void checkState(boolean condition, String errorMsg) {
+    if (!condition) throw new IllegalArgumentException(errorMsg);
+  }
+
+  public static String getFullyQualifiedName(PsiParameter psiParameter) {
+    PsiTypeElement typeElement = psiParameter.getTypeElement();
+    if (typeElement == null) throw new RuntimeException("Parameter has null typeElement " + psiParameter.getName());
+
+    PsiType psiType = typeElement.getType();
+
+    return psiType.getCanonicalText();
+  }
+
+  public boolean matchesPsiMethod(PsiMethod psiMethod) {
+    if (!myMethodName.equals(psiMethod.getName())) return false;
+
+    PsiClass containingClass = psiMethod.getContainingClass();
+    if (containingClass == null) return false;
+
+    String qualifiedName = containingClass.getQualifiedName();
+    if (qualifiedName == null) return false;
+
+    if (!myClassName.equals(qualifiedName)) return false;
+
+    PsiParameterList psiParameterList = psiMethod.getParameterList();
+    if (myParameterClassList.size() != psiParameterList.getParameters().length) return false;
+
+    for (int i = 0; i < psiParameterList.getParameters().length; i++) {
+      PsiParameter psiParameter = psiParameterList.getParameters()[i];
+      PsiTypeElement psiTypeElement = psiParameter.getTypeElement();
+      if (psiTypeElement == null) return false;
+
+      PsiType psiType = psiTypeElement.getType();
+      String parameterCanonicalText = psiType.getCanonicalText();
+      String myParameterCanonicalText = myParameterClassList.get(i);
+      if (!myParameterCanonicalText.equals(parameterCanonicalText)) return false;
+    }
+
+    return true;
+  }
+
+  public boolean matchesPsiMethod(PsiMethod psiMethod, int paramIndex) {
+    if (matchesPsiMethod(psiMethod) && paramIndex == myCheckedParameterIndex) return true;
+
+    return false;
+  }
+
+  public boolean overlaps(ConditionChecker otherChecker) {
+    if (myClassName.equals(otherChecker.myClassName) &&
+        myMethodName.equals(otherChecker.myMethodName) &&
+        myParameterClassList.equals(otherChecker.myParameterClassList) &&
+        myCheckedParameterIndex == otherChecker.myCheckedParameterIndex) {
+      return true;
+    }
+
+    return false;
+  }
 
   @NotNull
-  Type getType();
+  public Type getConditionCheckType() {
+    return myConditionCheckType;
+  }
+
+  @NotNull
+  public String getClassName() {
+    return myClassName;
+  }
+
+  @NotNull
+  public String getMethodName() {
+    return myMethodName;
+  }
+
+  public int getCheckedParameterIndex() {
+    return myCheckedParameterIndex;
+  }
+
+  public String getFullName() {
+    return myFullName;
+  }
+
+  /**
+   * In addition to normal duties, this controls the manner in which the ConditionCheck appears in the ConditionCheckDialog.MethodsPanel
+   */
+  @Override
+  public String toString() {
+    return myFullName;
+  }
+
+  private static class Builder {
+
+    static String initFullName(String className,
+                               String methodName,
+                               List<String> parameterClasses,
+                               List<String> parameterNames,
+                               int checkedParameterIndex) {
+      String s = className + "." + methodName + "(";
+      int index = 0;
+      for (String parameterClass : parameterClasses) {
+        String parameterClassAndName = parameterClass + " " + parameterNames.get(index);
+        if (index == checkedParameterIndex) parameterClassAndName = "*" + parameterClassAndName + "*";
+
+        s += parameterClassAndName + ", ";
+        index++;
+      }
+      s = s.substring(0, s.length() - 2);
+      s += ")";
+      return s;
+    }
+  }
+
+  static class FromConfigBuilder extends Builder {
+    private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.ConditionCheck.FromConfigBuilder");
+    private final @NotNull String serializedRepresentation;
+    private final @NotNull Type type;
+
+    FromConfigBuilder(@NotNull String serializedRepresentation, @NotNull Type type) {
+      this.serializedRepresentation = serializedRepresentation;
+      this.type = type;
+    }
+
+    private String parseClassAndMethodName() {
+      if (!serializedRepresentation.contains("(")) {
+        throw new IllegalArgumentException("Name should contain a opening parenthesis.  " + serializedRepresentation);
+      }
+      else if (!serializedRepresentation.contains(")")) {
+        throw new IllegalArgumentException("Name should contain a closing parenthesis.  " + serializedRepresentation);
+      }
+      else if (serializedRepresentation.indexOf("(", serializedRepresentation.indexOf("(") + 1) > -1) {
+        throw new IllegalArgumentException("Name should only contain one opening parenthesis.  " + serializedRepresentation);
+      }
+      else if (serializedRepresentation.indexOf(")", serializedRepresentation.indexOf(")") + 1) > -1) {
+        throw new IllegalArgumentException("Name should only contain one closing parenthesis.  " + serializedRepresentation);
+      }
+      else if (serializedRepresentation.indexOf(")") < serializedRepresentation.indexOf("(")) {
+        throw new IllegalArgumentException("Opening parenthesis should precede closing parenthesis.  " + serializedRepresentation);
+      }
+
+      String classAndMethodName = serializedRepresentation.substring(0, serializedRepresentation.indexOf("("));
+      if (!classAndMethodName.contains(".")) {
+        throw new IllegalArgumentException(
+          "Name should contain a dot between the class name and method name (before the opening parenthesis).  " +
+          serializedRepresentation);
+      }
+      return classAndMethodName;
+    }
+
+    @Nullable
+    public ConditionChecker build() {
+      try {
+        String classAndMethodName = parseClassAndMethodName();
+
+        String className = classAndMethodName.substring(0, classAndMethodName.lastIndexOf("."));
+        String methodName = classAndMethodName.substring(classAndMethodName.lastIndexOf(".") + 1);
+
+        String allParametersSubString =
+          serializedRepresentation.substring(serializedRepresentation.indexOf("(") + 1, serializedRepresentation.lastIndexOf(")")).trim();
+        if (allParametersSubString.isEmpty()) {
+          throw new IllegalArgumentException(
+            "Name should contain 1+ parameter (between opening and closing parenthesis).  " + serializedRepresentation);
+        }
+        else if (allParametersSubString.contains("*") && allParametersSubString.indexOf("*") == allParametersSubString.lastIndexOf("*")) {
+          throw new IllegalArgumentException("Selected Parameter should be surrounded by asterisks.  " + serializedRepresentation);
+        }
+
+        List<String> parameterClasses = new ArrayList<String>();
+        List<String> parameterNames = new ArrayList<String>();
+        int checkParameterIndex = -1;
+        int index = 0;
+        for (String parameterClassAndName : allParametersSubString.split(",")) {
+          parameterClassAndName = parameterClassAndName.trim();
+          if (parameterClassAndName.startsWith("*") && parameterClassAndName.endsWith("*")) {
+            checkParameterIndex = index;
+            parameterClassAndName = parameterClassAndName.substring(1, parameterClassAndName.length() - 1);
+          }
+
+          String[] parameterClassAndNameSplit = parameterClassAndName.split(" ");
+          String parameterClass = parameterClassAndNameSplit[0];
+          String parameterName = parameterClassAndNameSplit[1];
+          parameterClasses.add(parameterClass);
+          parameterNames.add(parameterName);
+          index++;
+        }
+        String fullName = initFullName(className, methodName, parameterClasses, parameterNames, checkParameterIndex);
+        return new ConditionChecker(className, methodName, parameterClasses, checkParameterIndex, type, fullName);
+      }
+      catch (Exception e) {
+        LOG.error("An Exception occurred while attempting to build ConditionCheck for Serialized String '" +
+                  serializedRepresentation +
+                  "' and Type '" +
+                  type +
+                  "'", e);
+        return null;
+      }
+    }
+  }
+
+  public static class FromPsiBuilder extends Builder {
+    private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.ConditionCheck.FromPsiBuilder");
+    private final @NotNull PsiMethod psiMethod;
+    private final @NotNull PsiParameter psiParameter;
+    private final @NotNull Type type;
+
+    public FromPsiBuilder(@NotNull PsiMethod psiMethod, @NotNull PsiParameter psiParameter, @NotNull Type type) {
+      this.psiMethod = psiMethod;
+      this.psiParameter = psiParameter;
+      this.type = type;
+    }
+
+    private static void validatePsiMethodHasContainingClass(PsiMethod psiMethod) {
+      PsiElement psiElement = psiMethod.getContainingClass();
+      if (!(psiElement instanceof PsiClass)) {
+        throw new IllegalArgumentException("PsiMethod " + psiMethod + " can not have a null containing class.");
+      }
+    }
+
+    private static void validatePsiMethodReturnTypeForNonAsserts(PsiMethod psiMethod, Type type) {
+      PsiType returnType = psiMethod.getReturnType();
+      if (isAssert(type)) return;
+
+      if (returnType == null) throw new IllegalArgumentException("PsiMethod " + psiMethod + " has a null return type PsiType.");
+
+      if (returnType != PsiType.BOOLEAN && !returnType.getCanonicalText().equals(Boolean.class.toString())) {
+        throw new IllegalArgumentException("PsiMethod " + psiMethod + " must have a null return type PsiType of boolean or Boolean.");
+      }
+    }
+
+    private static void validatePsiParameterExistsInPsiMethod(PsiMethod psiMethod, PsiParameter psiParameter) {
+      boolean parameterFound = false;
+      PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      for (PsiParameter parameter : parameters) {
+        if (psiParameter.equals(parameter)) {
+          parameterFound = true;
+          break;
+        }
+      }
+
+      if (!parameterFound) {
+        throw new IllegalArgumentException("PsiMethod " + psiMethod + " must have parameter " + getFullyQualifiedName(psiParameter));
+      }
+    }
+
+    private static boolean isAssert(Type type) {
+      return type == Type.ASSERT_IS_NULL_METHOD ||
+             type == Type.ASSERT_IS_NOT_NULL_METHOD ||
+             type == Type.ASSERT_TRUE_METHOD ||
+             type == Type.ASSERT_FALSE_METHOD;
+    }
+
+    private static String initClassNameFromPsiMethod(PsiMethod psiMethod) {
+      PsiElement psiElement = psiMethod.getContainingClass();
+      PsiClass psiClass = (PsiClass)psiElement;
+      if (psiClass == null) throw new IllegalStateException("PsiClass is null");
+
+      String qualifiedName = psiClass.getQualifiedName();
+      if (qualifiedName == null || qualifiedName.isEmpty()) throw new IllegalStateException("Qualified Name is Blank");
+      return qualifiedName;
+    }
+
+    private static String initMethodNameFromPsiMethod(PsiMethod psiMethod) {
+      return psiMethod.getName();
+    }
+
+    private static List<String> initParameterClassListFromPsiMethod(PsiMethod psiMethod) {
+      List<String> parameterClasses = new ArrayList<String>();
+      PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      for (PsiParameter param : parameters) {
+        PsiTypeElement typeElement = param.getTypeElement();
+        if (typeElement == null) throw new RuntimeException("Parameter has null typeElement " + param.getName());
+
+        PsiType psiType = typeElement.getType();
+
+        parameterClasses.add(psiType.getCanonicalText());
+      }
+      return parameterClasses;
+    }
+
+    private static List<String> initParameterNameListFromPsiMethod(PsiMethod psiMethod) {
+      List<String> parameterNames = new ArrayList<String>();
+      PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      for (PsiParameter param : parameters) {
+        parameterNames.add(param.getName());
+      }
+      return parameterNames;
+    }
+
+    private static int initCheckedParameterIndex(PsiMethod psiMethod, PsiParameter psiParameterToFind) {
+      PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      for (int i = 0; i < parameters.length; i++) {
+        PsiParameter param = parameters[i];
+        if (param.equals(psiParameterToFind)) return i;
+      }
+      throw new IllegalStateException();
+    }
+
+    private void validateConstructorArgs(PsiMethod psiMethod, PsiParameter psiParameter) {
+      validatePsiMethodHasContainingClass(psiMethod);
+      validatePsiMethodReturnTypeForNonAsserts(psiMethod, type);
+      validatePsiParameterExistsInPsiMethod(psiMethod, psiParameter);
+    }
+
+    @Nullable
+    public ConditionChecker build() {
+      try {
+        validateConstructorArgs(psiMethod, psiParameter);
+
+        String className = initClassNameFromPsiMethod(psiMethod);
+        String methodName = initMethodNameFromPsiMethod(psiMethod);
+        List<String> parameterClassList = initParameterClassListFromPsiMethod(psiMethod);
+        List<String> parameterNameList = initParameterNameListFromPsiMethod(psiMethod);
+        int checkedParameterIndex = initCheckedParameterIndex(psiMethod, psiParameter);
+        String fullName = initFullName(className, methodName, parameterClassList, parameterNameList, checkedParameterIndex);
+        return new ConditionChecker(className, methodName, parameterClassList, checkedParameterIndex, type, fullName);
+      }
+      catch (Exception e) {
+        LOG.error("An Exception occurred while attempting to build ConditionCheck for PsiMethod '" + psiMethod +
+                  "' PsiParameter='" + psiParameter + "' " +
+                  "' and Type '" +
+                  type +
+                  "'", e);
+        return null;
+      }
+    }
+  }
 }
diff --git a/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java b/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
deleted file mode 100644
index 46c3121d6619..000000000000
--- a/java/java-impl/src/com/intellij/codeInsight/MethodConditionCheck.java
+++ /dev/null
@@ -1,395 +0,0 @@
-/*
- * 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.codeInsight;
-
-import com.intellij.openapi.project.*;
-import com.intellij.psi.*;
-import com.intellij.psi.search.*;
-import org.jetbrains.annotations.*;
-
-import java.util.*;
-
-import static com.intellij.codeInsight.ConditionChecker.Type.*;
-
-/**
- * Used by Constant Condition Inspection to identify methods which perform some type of Validation on the parameters passed into them.
- * For example given the following method
- * <pre>
- * {@code
- *  class Foo {
- *     static boolean validateNotNull(Object o) {
- *       if (o == null) return false;
- *       else return true;
- *     }
- *   }
- * }
- *
- * The corresponding MethodConditionCheck would be <p/>
- * myType=Type.IS_NOT_NULL_METHOD
- * myPsiClass=Foo
- * myPsiMethod=validateNotNull
- * myPsiParameter=o
- *
- * The following block of code would produce a Inspection Warning that o is always true
- *
- *  <pre>
- * {@code
- *   if (Value.isNotNull(o)) {
- *     if(o != null) {}
- *   }
- * }
- * </pre>
- *
- * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
- *         Creation Date: 8/14/12
- */
-public class MethodConditionCheck implements ConditionChecker, Comparable<MethodConditionCheck> {
-  private final @NotNull Type myType;
-  private final @NotNull PsiClass myPsiClass;
-  private final @NotNull PsiMethod myPsiMethod;
-  private final @NotNull PsiParameter myPsiParameter;
-  private final String fullName;
-  private final String shortName;
-
-  public MethodConditionCheck(@NotNull PsiMethod psiMethod, @NotNull PsiParameter psiParameter, @NotNull Type type) {
-    myPsiMethod = psiMethod;
-    myPsiParameter = psiParameter;
-    if (type != IS_NULL_METHOD && type != IS_NOT_NULL_METHOD &&
-        type != ASSERT_IS_NULL_METHOD && type != ASSERT_IS_NOT_NULL_METHOD &&
-        type != ASSERT_TRUE_METHOD && type != ASSERT_FALSE_METHOD)
-      throw new IllegalArgumentException("Type is invalid " + type);
-
-    PsiClass containingClass = psiMethod.getContainingClass();
-    if (containingClass == null)
-      throw new IllegalArgumentException("PsiMethod has null Containing Class");
-
-    myPsiClass = containingClass;
-    myType = type;
-
-    validatePsiMethod();
-    String className = initClassNameFromPsiMethod();
-    String methodName = initMethodNameFromPsiMethod();
-    List<String> parameters = initParameterNamesFromPsiMethod(myPsiParameter);
-    fullName = initFullName(className, methodName, parameters);
-    shortName = initShortName(methodName, parameters);
-  }
-
-  @Override
-  public boolean matches(PsiMethod psiMethod) {
-    if (myPsiMethod.equals(psiMethod)) {
-      return true;
-    }
-
-    // The equals method in PsiMethod compares to see if they are the same object, but sometimes they are not the same object but do represent the same method
-    if (!myPsiMethod.getName().equals(psiMethod.getName())) return false;
-
-    PsiClass myContainingClass = myPsiMethod.getContainingClass();
-    PsiClass containingClass = myPsiMethod.getContainingClass();
-    if (myContainingClass == null && containingClass != null) return false;
-    if (myContainingClass != null && containingClass == null) return false;
-    if (myContainingClass != null) {   // Both must be non-null
-      String myQualifiedName = myContainingClass.getQualifiedName();
-      String qualifiedName = containingClass.getQualifiedName();
-      if (myQualifiedName == null && qualifiedName != null) return false;
-      if (myQualifiedName != null && qualifiedName == null) return false;
-      if (myQualifiedName != null && !myQualifiedName.equals(qualifiedName)) return false;
-    }
-
-    PsiParameterList myPsiParameterList = myPsiMethod.getParameterList();
-    PsiParameterList psiParameterList = psiMethod.getParameterList();
-    if (myPsiParameterList.getParameters().length != psiParameterList.getParameters().length) return false;
-    for (int i = 0; i < myPsiParameterList.getParameters().length; i++) {
-      PsiParameter myPsiParameter = myPsiParameterList.getParameters()[i];
-      PsiParameter psiParameter = psiParameterList.getParameters()[i];
-      if (myPsiParameter == null && psiParameter != null) return false;
-      if (myPsiParameter != null && psiParameter == null) return false;
-      if (myPsiParameter != null) { // Both must be non-null
-        PsiTypeElement myPsiTypeElement = myPsiParameter.getTypeElement();
-        PsiTypeElement psiTypeElement = psiParameter.getTypeElement();
-        if (myPsiTypeElement == null && psiTypeElement != null) return false;
-        if (myPsiTypeElement != null && psiTypeElement == null) return false;
-        if (myPsiTypeElement != null && myPsiTypeElement.getType() == psiTypeElement.getType()) return false;
-      }
-    }
-
-    return true;
-  }
-
-  @Override
-  public boolean matches(PsiMethod psiMethod, int paramIndex) {
-    if (matches(psiMethod)) {
-      PsiParameter[] parameters = myPsiMethod.getParameterList().getParameters();
-      if (parameters.length <= paramIndex)
-        return false;
-
-      PsiParameter parameter = parameters[paramIndex];
-      if (parameter.equals(myPsiParameter))
-        return true;
-      else
-        return false;
-    }
-
-    return false;
-  }
-
-  @Override
-  public boolean overlaps(ConditionChecker checker) {
-    MethodConditionCheck otherChecker = (MethodConditionCheck) checker;
-    if (myPsiClass.equals(otherChecker.myPsiClass) && myPsiMethod.equals(otherChecker.myPsiMethod) && myPsiParameter.equals(otherChecker.myPsiParameter))
-      return true;
-
-    return false;
-  }
-
-  @NotNull
-  @Override
-  public Type getType() {
-    return myType;
-  }
-
-  private void validatePsiMethod() {
-    PsiElement psiElement = myPsiMethod.getContainingClass();
-    if (psiElement == null)
-      throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " can not have a null containing class.");
-
-    PsiType returnType = myPsiMethod.getReturnType();
-    if (!isAssert()) {
-      if (returnType == null)
-        throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " has a null return type PsiType.");
-
-      if (returnType != PsiType.BOOLEAN && !returnType.getCanonicalText().equals(Boolean.class.toString())) {
-        throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " must have a null return type PsiType of boolean or Boolean.");
-      }
-    }
-
-    boolean parameterFound = false;
-    for (int i = 0; i < myPsiMethod.getParameterList().getParameters().length; i++) {
-      if (myPsiParameter.equals(myPsiMethod.getParameterList().getParameters()[i])) {
-        parameterFound = true;
-        break;
-      }
-    }
-
-    if (!parameterFound) {
-      throw new IllegalArgumentException("PsiMethod " + myPsiMethod + " must have parameter " + getFullyQualifiedName(myPsiParameter));
-    }
-  }
-
-  private boolean isAssert() {
-    return myType == ASSERT_IS_NULL_METHOD || myType == ASSERT_IS_NOT_NULL_METHOD || myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD;
-  }
-
-  private String initClassNameFromPsiMethod() {
-    return myPsiMethod.getContainingClass().getQualifiedName();
-  }
-
-  private String initMethodNameFromPsiMethod() {
-    return myPsiMethod.getName();
-  }
-
-  private List<String> initParameterNamesFromPsiMethod(PsiParameter selectedParameter) {
-    List<String> parameters = new ArrayList<String>();
-    for (int i = 0; i < myPsiMethod.getParameterList().getParameters().length; i++) {
-      PsiParameter param = myPsiMethod.getParameterList().getParameters()[i];
-      String parameter = getFullyQualifiedName(param);
-      if (param.equals(selectedParameter))
-        parameters.add("*" + parameter + "*");
-      else
-        parameters.add(parameter);
-    }
-    return parameters;
-  }
-
-  public static String getFullyQualifiedName(PsiParameter psiParameter) {
-    PsiTypeElement typeElement = psiParameter.getTypeElement();
-    if (typeElement == null)
-      throw new RuntimeException("Parameter has null typeElement " + psiParameter.getName());
-
-    PsiType psiType = typeElement.getType();
-
-    return psiType.getCanonicalText() + " " + psiParameter.getName();
-  }
-
-  private static String initFullName(String className, String methodName, List<String> parameters) {
-    String s = className + "." + methodName + "(";
-    for (String parameterName : parameters) {
-      s += parameterName + ", ";
-    }
-    s = s.substring(0, s.length() - 2);
-    s += ")";
-    return s;
-  }
-
-  private static String initShortName(String methodName, List<String> parameterNames) {
-    String shortName = methodName + "(";
-    for (String parameterName : parameterNames) {
-      if (parameterNames.lastIndexOf(".") > -1)
-        shortName += parameterName.substring(parameterName.lastIndexOf(".") + 1) + ", ";
-      else
-        shortName += parameterName + ", ";
-    }
-    shortName = shortName.substring(0, shortName.lastIndexOf(", "));
-    shortName += ")";
-    return shortName;
-  }
-
-  @NotNull
-  public PsiMethod getPsiMethod() {
-    return myPsiMethod;
-  }
-
-  public String getShortName() {
-    return shortName;
-  }
-
-  @NotNull
-  public PsiParameter getPsiParameter() {
-    return myPsiParameter;
-  }
-
-
-  @Override
-  public int compareTo(MethodConditionCheck o) {
-    return fullName.compareToIgnoreCase(fullName);
-  }
-
-  @Override
-  public String toString() {
-    return fullName;
-  }
-
-  static class Builder {
-    private final @NotNull String serializedRepresentation;
-    private final @NotNull Project project;
-    private final @NotNull Type type;
-
-
-    Builder(@NotNull String serializedRepresentation, @NotNull Type type, @NotNull Project project) {
-      this.serializedRepresentation = serializedRepresentation;
-      this.project = project;
-      this.type = type;
-    }
-
-    private MethodConditionCheck validateFullyQualifiedClassMethodAndParameterNameAndGetPsiMethod(String fullyQualifiedClassMethodAndParameterName) {
-      String classNameAndMethodName = parseClassNameAndMethodName(fullyQualifiedClassMethodAndParameterName);
-
-      String className = classNameAndMethodName.substring(0, classNameAndMethodName.lastIndexOf("."));
-      String methodName = classNameAndMethodName.substring(classNameAndMethodName.lastIndexOf(".") + 1);
-
-      String allParametersSubString = fullyQualifiedClassMethodAndParameterName.substring(fullyQualifiedClassMethodAndParameterName.indexOf("(") + 1, fullyQualifiedClassMethodAndParameterName.lastIndexOf(")")).trim();
-      if (allParametersSubString.isEmpty()) {
-        throw new IllegalArgumentException("Name should contain 1+ parameter (between opening and closing parenthesis).  " + fullyQualifiedClassMethodAndParameterName);
-      } else if (allParametersSubString.contains("*") && allParametersSubString.indexOf("*") == allParametersSubString.lastIndexOf("*")) {
-        throw new IllegalArgumentException("Selected Parameter should be surrounded by asterisks.  " + fullyQualifiedClassMethodAndParameterName);
-      }
-
-      String parameterClassAndName = allParametersSubString.substring(allParametersSubString.indexOf("*") + 1, allParametersSubString.lastIndexOf("*")).trim();
-
-      PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(className, GlobalSearchScope.allScope(project));
-      if (psiClass == null) {
-        throw new IllegalArgumentException("Unable to locate class " + className + " which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
-      }
-
-      List<PsiMethod> psiMethods = findPsiMethodsInPsiClassWithMatchingMethodName(psiClass, methodName);
-      if (psiMethods.size() == 0) {
-        throw new IllegalArgumentException("Unable to locate method in class " + className + " named " + methodName + ", which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
-      }
-
-      PsiMethod psiMethod = findPsiMethodWithMatchingParameters(psiMethods, allParametersSubString);
-      if (psiMethod == null) {
-        throw new IllegalArgumentException("Unable to locate method in class " + className + " named " + methodName + " with a parameter named " + parameterClassAndName + " which was parsed from full name " + fullyQualifiedClassMethodAndParameterName + ".  The following methods matched on method name but not parameter name " + psiMethods);
-      }
-
-      PsiParameter psiParameter = null;
-      for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
-        PsiParameter parameter = psiMethod.getParameterList().getParameters()[i];
-        if (parameterClassAndName.equals(getFullyQualifiedName(parameter))) {
-          psiParameter = parameter;
-          break;
-        }
-      }
-
-      if (psiParameter == null) {
-        throw new IllegalArgumentException("Unable to locate parameter " + parameterClassAndName + " in class " + className + " named " + methodName + ", which was parsed from full name " + fullyQualifiedClassMethodAndParameterName);
-      }
-
-      return new MethodConditionCheck(psiMethod, psiParameter, type);
-    }
-
-    private static String parseClassNameAndMethodName(String fullyQualifiedClassMethodAndParameterName) {
-      if (!fullyQualifiedClassMethodAndParameterName.contains("(")) {
-        throw new IllegalArgumentException("Name should contain a opening parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
-      } else if (!fullyQualifiedClassMethodAndParameterName.contains(")")) {
-        throw new IllegalArgumentException("Name should contain a closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
-      } else if (fullyQualifiedClassMethodAndParameterName.indexOf("(", fullyQualifiedClassMethodAndParameterName.indexOf("(") + 1) > -1) {
-        throw new IllegalArgumentException("Name should only contain one opening parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
-      } else if (fullyQualifiedClassMethodAndParameterName.indexOf(")", fullyQualifiedClassMethodAndParameterName.indexOf(")") + 1) > -1) {
-        throw new IllegalArgumentException("Name should only contain one closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
-      } else if (fullyQualifiedClassMethodAndParameterName.indexOf(")") < fullyQualifiedClassMethodAndParameterName.indexOf("(")) {
-        throw new IllegalArgumentException("Opening parenthesis should precede closing parenthesis.  " + fullyQualifiedClassMethodAndParameterName);
-      }
-
-      String classNameAndMethodName = fullyQualifiedClassMethodAndParameterName.substring(0, fullyQualifiedClassMethodAndParameterName.indexOf("("));
-      if (!classNameAndMethodName.contains(".")) {
-        throw new IllegalArgumentException("Name should contain a dot between the class name and method name (before the opening parenthesis).  " + fullyQualifiedClassMethodAndParameterName);
-      }
-      return classNameAndMethodName;
-    }
-
-    private static PsiMethod findPsiMethodWithMatchingParameters(List<PsiMethod> psiMethods, String allParametersSubString) {
-      String[] parameterClassAndNameArray = allParametersSubString.split(",");
-      List<String> parameterClassToMatch = new ArrayList<String>();
-      for (String parameterClassAndName : parameterClassAndNameArray) {
-        parameterClassAndName = parameterClassAndName.replace("*", "").trim();
-        parameterClassAndName = parameterClassAndName.substring(0, parameterClassAndName.indexOf(" ")).trim();
-        parameterClassToMatch.add(parameterClassAndName);
-      }
-
-      for (PsiMethod method : psiMethods) {
-        List<String> parameterForCurrentMethod = new ArrayList<String>();
-        for (int i = 0; i < method.getParameterList().getParameters().length; i++) {
-          PsiParameter psiParameter = method.getParameterList().getParameters()[i];
-          PsiTypeElement typeElement = psiParameter.getTypeElement();
-          if (typeElement == null)
-            break;
-
-          PsiType psiType = typeElement.getType();
-          parameterForCurrentMethod.add(psiType.getCanonicalText().trim());
-        }
-
-        if (parameterForCurrentMethod.equals(parameterClassToMatch))
-          return method;
-      }
-
-      return null;
-    }
-
-    private static List<PsiMethod> findPsiMethodsInPsiClassWithMatchingMethodName(PsiClass psiClass, String methodName) {
-      List<PsiMethod> psiMethods = new ArrayList<PsiMethod>();
-      for (int i = 0; i < psiClass.getMethods().length; i++) {
-        PsiMethod possibleMatchPsiMethod = psiClass.getMethods()[i];
-        if (methodName.equals(possibleMatchPsiMethod.getName())) {
-          psiMethods.add(possibleMatchPsiMethod);
-        }
-      }
-      return psiMethods;
-    }
-
-    public MethodConditionCheck build() {
-      return validateFullyQualifiedClassMethodAndParameterNameAndGetPsiMethod(serializedRepresentation);
-    }
-  }
-}
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
index d48698d2dfa4..0f8a7257efdf 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/ConditionCheckDialog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -33,12 +33,12 @@ import java.util.List;
  * Dialog that appears when user clicks the "Configure IsNull/IsNotNull/True/False Check/Assertion Methods"
  * on the Errors dialog for the Constant Conditions Inspection.  It is divided into 6 parts
  * <ol>
- *   <li>Is Null Check MethodsPanel</li>
- *   <li>Is Not Null Check MethodsPanel</li>
- *   <li>Assert Is Null MethodsPanel</li>
- *   <li>Assert Is Not Null MethodsPanel</li>
- *   <li>Assert True MethodsPanel</li>
- *   <li>Assert False MethodsPanel</li>
+ * <li>Is Null Check MethodsPanel</li>
+ * <li>Is Not Null Check MethodsPanel</li>
+ * <li>Assert Is Null MethodsPanel</li>
+ * <li>Assert Is Not Null MethodsPanel</li>
+ * <li>Assert True MethodsPanel</li>
+ * <li>Assert False MethodsPanel</li>
  * </ol>
  *
  * @author <a href="mailto:johnnyclark@gmail.com">Johnny Clark</a>
@@ -65,12 +65,12 @@ public class ConditionCheckDialog extends DialogWrapper {
     final Splitter isNullIsNotNullCheckMethodSplitter = new Splitter(false);
     final Splitter assertTrueFalseMethodSplitter = new Splitter(false);
 
-    List<MethodConditionCheck> isNullCheckMethods = new ArrayList<MethodConditionCheck>(manager.getIsNullCheckMethods());
-    List<MethodConditionCheck> isNotNullCheckMethods = new ArrayList<MethodConditionCheck>(manager.getIsNotNullCheckMethods());
-    List<MethodConditionCheck> assertIsNullMethods = new ArrayList<MethodConditionCheck>(manager.getAssertIsNullMethods());
-    List<MethodConditionCheck> assertIsNotNullMethods = new ArrayList<MethodConditionCheck>(manager.getAssertIsNotNullMethods());
-    List<MethodConditionCheck> assertTrueMethods = new ArrayList<MethodConditionCheck>(manager.getAssertTrueMethods());
-    List<MethodConditionCheck> assertFalseMethods = new ArrayList<MethodConditionCheck>(manager.getAssertFalseMethods());
+    List<ConditionChecker> isNullCheckMethods = new ArrayList<ConditionChecker>(manager.getIsNullCheckMethods());
+    List<ConditionChecker> isNotNullCheckMethods = new ArrayList<ConditionChecker>(manager.getIsNotNullCheckMethods());
+    List<ConditionChecker> assertIsNullMethods = new ArrayList<ConditionChecker>(manager.getAssertIsNullMethods());
+    List<ConditionChecker> assertIsNotNullMethods = new ArrayList<ConditionChecker>(manager.getAssertIsNotNullMethods());
+    List<ConditionChecker> assertTrueMethods = new ArrayList<ConditionChecker>(manager.getAssertTrueMethods());
+    List<ConditionChecker> assertFalseMethods = new ArrayList<ConditionChecker>(manager.getAssertFalseMethods());
 
     myAssertIsNullMethodPanel = new MethodsPanel(assertIsNullMethods, ConditionChecker.Type.ASSERT_IS_NULL_METHOD, myProject);
     myAssertIsNotNullMethodPanel = new MethodsPanel(assertIsNotNullMethods, ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD, myProject);
@@ -92,15 +92,27 @@ public class ConditionCheckDialog extends DialogWrapper {
     mainSplitter.setFirstComponent(topThirdSplitter);
     mainSplitter.setSecondComponent(bottomTwoThirdsSplitter);
 
-    topThirdSplitter.setPreferredSize(new Dimension(600, 400));
-    bottomTwoThirdsSplitter.setPreferredSize(new Dimension(600, 800));
+    topThirdSplitter.setPreferredSize(new Dimension(600, 150));
+    bottomTwoThirdsSplitter.setPreferredSize(new Dimension(600, 300));
 
-    myAssertIsNullMethodPanel.setOtherMethodsPanels(myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
-    myAssertIsNotNullMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
-    myIsNullCheckMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
-    myIsNotNullCheckMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myAssertTrueMethodPanel, myAssertFalseMethodPanel);
-    myAssertTrueMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel, myAssertFalseMethodPanel);
-    myAssertFalseMethodPanel.setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel, myAssertTrueMethodPanel);
+    myAssertIsNullMethodPanel
+      .setOtherMethodsPanels(myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel,
+                             myAssertFalseMethodPanel);
+    myAssertIsNotNullMethodPanel
+      .setOtherMethodsPanels(myAssertIsNullMethodPanel, myIsNullCheckMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel,
+                             myAssertFalseMethodPanel);
+    myIsNullCheckMethodPanel
+      .setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myAssertTrueMethodPanel,
+                             myAssertFalseMethodPanel);
+    myIsNotNullCheckMethodPanel
+      .setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNullCheckMethodPanel, myAssertTrueMethodPanel,
+                             myAssertFalseMethodPanel);
+    myAssertTrueMethodPanel
+      .setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel,
+                             myAssertFalseMethodPanel);
+    myAssertFalseMethodPanel
+      .setOtherMethodsPanels(myAssertIsNullMethodPanel, myAssertIsNotNullMethodPanel, myIsNotNullCheckMethodPanel, myIsNullCheckMethodPanel,
+                             myAssertTrueMethodPanel);
 
     init();
     setTitle(mainDialogTitle);
@@ -114,12 +126,12 @@ public class ConditionCheckDialog extends DialogWrapper {
   @Override
   protected void doOKAction() {
     final ConditionCheckManager manager = ConditionCheckManager.getInstance(myProject);
-    manager.setIsNotNullCheckMethods(myIsNotNullCheckMethodPanel.getMethodConditionChecker());
-    manager.setIsNullCheckMethods(myIsNullCheckMethodPanel.getMethodConditionChecker());
-    manager.setAssertNotNullMethods(myAssertIsNotNullMethodPanel.getMethodConditionChecker());
-    manager.setAssertNullMethods(myAssertIsNullMethodPanel.getMethodConditionChecker());
-    manager.setAssertTrueMethods(myAssertTrueMethodPanel.getMethodConditionChecker());
-    manager.setAssertFalseMethods(myAssertFalseMethodPanel.getMethodConditionChecker());
+    manager.setIsNotNullCheckMethods(myIsNotNullCheckMethodPanel.getConditionChecker());
+    manager.setIsNullCheckMethods(myIsNullCheckMethodPanel.getConditionChecker());
+    manager.setAssertIsNotNullMethods(myAssertIsNotNullMethodPanel.getConditionChecker());
+    manager.setAssertIsNullMethods(myAssertIsNullMethodPanel.getConditionChecker());
+    manager.setAssertTrueMethods(myAssertTrueMethodPanel.getConditionChecker());
+    manager.setAssertFalseMethods(myAssertFalseMethodPanel.getConditionChecker());
 
     super.doOKAction();
   }
@@ -133,12 +145,12 @@ public class ConditionCheckDialog extends DialogWrapper {
     private final @NotNull Project myProject;
     private Set<MethodsPanel> otherPanels;
 
-    public MethodsPanel(final List<MethodConditionCheck> checkers, final ConditionChecker.Type type, final Project myProject) {
+    public MethodsPanel(final List<ConditionChecker> checkers, final ConditionChecker.Type type, final @NotNull Project myProject) {
       this.myProject = myProject;
-      myList = new JBList(new CollectionListModel<MethodConditionCheck>(checkers));
+      myList = new JBList(new CollectionListModel<ConditionChecker>(checkers));
       myPanel = new JPanel(new BorderLayout());
       myPanel.setBorder(IdeBorderFactory.createTitledBorder(initTitle(type), false, new Insets(10, 0, 0, 0)));
-      myPanel.setPreferredSize(new Dimension(500, 500));
+      myPanel.setPreferredSize(new Dimension(400, 150));
 
       myList.setCellRenderer(new ColoredListCellRenderer() {
         @Override
@@ -147,25 +159,29 @@ public class ConditionCheckDialog extends DialogWrapper {
           if (s.contains("*")) {
             int indexOfAsterix1 = s.indexOf("*");
             int indexOfAsterix2 = s.lastIndexOf("*");
-            if (indexOfAsterix1 >= 0 && indexOfAsterix1 < s.length() && indexOfAsterix2 >= 0 && indexOfAsterix2 < s.length() && indexOfAsterix1 < indexOfAsterix2) {
+            if (indexOfAsterix1 >= 0 &&
+                indexOfAsterix1 < s.length() &&
+                indexOfAsterix2 >= 0 &&
+                indexOfAsterix2 < s.length() &&
+                indexOfAsterix1 < indexOfAsterix2) {
               append(s.substring(0, indexOfAsterix1), SimpleTextAttributes.REGULAR_ATTRIBUTES);
               append(s.substring(indexOfAsterix1 + 1, indexOfAsterix2), SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES);
               append(s.substring(indexOfAsterix2 + 1), SimpleTextAttributes.REGULAR_ATTRIBUTES);
-            } else {
+            }
+            else {
               append(s, SimpleTextAttributes.REGULAR_ATTRIBUTES);
             }
           }
         }
       });
 
-      final ToolbarDecorator toolbarDecorator = ToolbarDecorator.createDecorator(myList).disableUpDownActions()
-        .setAddAction(new AnActionButtonRunnable() {
+      final ToolbarDecorator toolbarDecorator =
+        ToolbarDecorator.createDecorator(myList).disableUpDownActions().setAddAction(new AnActionButtonRunnable() {
           @Override
           public void run(AnActionButton anActionButton) {
             chooseMethod(null, type, myList.getModel().getSize());
           }
-        })
-        .setRemoveAction(new AnActionButtonRunnable() {
+        }).setRemoveAction(new AnActionButtonRunnable() {
           @Override
           public void run(AnActionButton anActionButton) {
             CollectionListModel model = getCollectionListModel();
@@ -175,57 +191,65 @@ public class ConditionCheckDialog extends DialogWrapper {
           }
         });
 
-      myList.addMouseListener(
-        new MouseAdapter() {
-          public void mouseClicked(MouseEvent e) {
-            if (e.getClickCount() == 2) {
-              int index = myList.locationToIndex(e.getPoint());
-              CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
-              if (index >= 0 && model.getSize() > index) {
-                chooseMethod(model.getElementAt(index), type, index);
-              }
+      myList.addMouseListener(new MouseAdapter() {
+        public void mouseClicked(MouseEvent e) {
+          if (e.getClickCount() == 2) {
+            int index = myList.locationToIndex(e.getPoint());
+            CollectionListModel<ConditionChecker> model = getCollectionListModel();
+            if (index >= 0 && model.getSize() > index) {
+              chooseMethod(model.getElementAt(index), type, index);
             }
           }
         }
-      );
+      });
       final JPanel panel = toolbarDecorator.createPanel();
       myPanel.add(panel);
       myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     }
 
     private String initTitle(@NotNull ConditionChecker.Type type) {
-      if (type.equals(ConditionChecker.Type.IS_NULL_METHOD))
+      if (type.equals(ConditionChecker.Type.IS_NULL_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.isNull.method.panel.title");
-      else if (type.equals(ConditionChecker.Type.IS_NOT_NULL_METHOD))
+      }
+      else if (type.equals(ConditionChecker.Type.IS_NOT_NULL_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.isNotNull.method.panel.title");
-      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NULL_METHOD))
+      }
+      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NULL_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.assert.isNull.method.panel.title");
-      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD))
+      }
+      else if (type.equals(ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.assert.isNotNull.method.panel.title");
-      else if (type.equals(ConditionChecker.Type.ASSERT_TRUE_METHOD))
+      }
+      else if (type.equals(ConditionChecker.Type.ASSERT_TRUE_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.assert.true.method.panel.title");
-      else if (type.equals(ConditionChecker.Type.ASSERT_FALSE_METHOD))
+      }
+      else if (type.equals(ConditionChecker.Type.ASSERT_FALSE_METHOD)) {
         return InspectionsBundle.message("configure.checker.option.assert.false.method.panel.title");
-      else
+      }
+      else {
         throw new IllegalArgumentException("MethodCheckerDetailsDialog does not support type " + type);
-    }
-
-    private void chooseMethod(@Nullable MethodConditionCheck checker, ConditionChecker.Type type, int index) {
-      MethodCheckerDetailsDialog pickMethodPanel = new MethodCheckerDetailsDialog(checker, type, myProject, myPanel, getConditionCheckers(), getOtherCheckers());
-      pickMethodPanel.show();
-      MethodConditionCheck chk = pickMethodPanel.getMethodConditionChecker();
-      if (chk != null) {
-        CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
-        if (model.getSize() <= index)
-          model.add(chk);
-        else
-          model.setElementAt(chk, index);
       }
     }
 
-    private CollectionListModel<MethodConditionCheck> getCollectionListModel() {
+    private void chooseMethod(@Nullable ConditionChecker checker, ConditionChecker.Type type, int index) {
+      MethodCheckerDetailsDialog pickMethodPanel =
+        new MethodCheckerDetailsDialog(checker, type, myProject, myPanel, getConditionCheckers(), getOtherCheckers());
+      pickMethodPanel.show();
+      ConditionChecker chk = pickMethodPanel.getConditionChecker();
+      if (chk != null) {
+        CollectionListModel<ConditionChecker> model = getCollectionListModel();
+        if (model.getSize() <= index) {
+          model.add(chk);
+        }
+        else {
+          model.setElementAt(chk, index);
+        }
+      }
+    }
+
+    private CollectionListModel<ConditionChecker> getCollectionListModel() {
       //noinspection unchecked
-      return (CollectionListModel<MethodConditionCheck>) myList.getModel();
+      return (CollectionListModel<ConditionChecker>)myList.getModel();
     }
 
     @NotNull
@@ -233,14 +257,14 @@ public class ConditionCheckDialog extends DialogWrapper {
       return myPanel;
     }
 
-    public List<MethodConditionCheck> getMethodConditionChecker() {
-      CollectionListModel<MethodConditionCheck> model = getCollectionListModel();
-      return new ArrayList<MethodConditionCheck>(model.getItems());
+    public List<ConditionChecker> getConditionChecker() {
+      CollectionListModel<ConditionChecker> model = getCollectionListModel();
+      return new ArrayList<ConditionChecker>(model.getItems());
     }
 
     public Set<ConditionChecker> getConditionCheckers() {
       Set<ConditionChecker> set = new HashSet<ConditionChecker>();
-      set.addAll(getMethodConditionChecker());
+      set.addAll(getConditionChecker());
       return set;
     }
 
diff --git a/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java b/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
index cd261e1c9214..5d34364e6452 100644
--- a/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
+++ b/java/java-impl/src/com/intellij/codeInspection/dataFlow/MethodCheckerDetailsDialog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -45,33 +45,55 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
   private final @NotNull MethodDropDown methodDropDown;
   private final @NotNull ClassField classField;
   private final @NotNull Set<ConditionChecker> myOtherCheckers;
-  private final @Nullable MethodConditionCheck myPreviouslySelectedChecker;
-
+  private final @Nullable ConditionChecker myPreviouslySelectedChecker;
   /**
    * Set by the OK and/or Cancel actions so that the caller can retrieve it via a call to getMethodIsNullIsNotNullChecker
    */
-  private @Nullable MethodConditionCheck mySelectedChecker;
+  private @Nullable ConditionChecker mySelectedChecker;
 
-  MethodCheckerDetailsDialog(@Nullable MethodConditionCheck previouslySelectedChecker, @NotNull ConditionChecker.Type type, @NotNull Project project, @NotNull Component component, @NotNull Set<ConditionChecker> otherCheckersSameType, @NotNull Set<ConditionChecker> otherCheckers) {
+  MethodCheckerDetailsDialog(@Nullable ConditionChecker previouslySelectedChecker,
+                             @NotNull ConditionChecker.Type type,
+                             @NotNull Project project,
+                             @NotNull Component component,
+                             @NotNull Set<ConditionChecker> otherCheckersSameType,
+                             @NotNull Set<ConditionChecker> otherCheckers) {
     super(component, true);
-    if (!isSupported(type))
-      throw new IllegalArgumentException("Type is invalid " + type);
+    if (!isSupported(type)) throw new IllegalArgumentException("Type is invalid " + type);
 
     myProject = project;
     myType = type;
     myOtherCheckers = new HashSet<ConditionChecker>(otherCheckersSameType);
     myOtherCheckers.addAll(otherCheckers);
     myPreviouslySelectedChecker = previouslySelectedChecker;
-    if (myPreviouslySelectedChecker != null)
-      myOtherCheckers.remove(myPreviouslySelectedChecker);
+    if (myPreviouslySelectedChecker != null) myOtherCheckers.remove(myPreviouslySelectedChecker);
 
     PsiClass psiClass = null;
     PsiMethod psiMethod = null;
     PsiParameter psiParameter = null;
     if (previouslySelectedChecker != null) {
-      psiMethod = previouslySelectedChecker.getPsiMethod();
-      psiClass = psiMethod.getContainingClass();
-      psiParameter = previouslySelectedChecker.getPsiParameter();
+      psiClass =
+        JavaPsiFacade.getInstance(myProject).findClass(previouslySelectedChecker.getClassName(), GlobalSearchScope.allScope(myProject));
+      if (psiClass != null) {
+        for (PsiMethod method : psiClass.findMethodsByName(previouslySelectedChecker.getMethodName(), true)) {
+          if (previouslySelectedChecker.equals(buildParameterClassListFromPsiMethod(method))) {
+            psiMethod = method;
+            break;
+          }
+        }
+      }
+
+      if (psiMethod != null) {
+        PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+        if (parameters.length - 1 >= previouslySelectedChecker.getCheckedParameterIndex()) {
+          psiParameter = parameters[previouslySelectedChecker.getCheckedParameterIndex()];
+        }
+      }
+    }
+
+    if (psiClass == null || psiMethod == null || psiParameter == null) {
+      psiClass = null;
+      psiMethod = null;
+      psiParameter = null;
     }
 
     classField = new ClassField(myProject, psiClass);
@@ -94,21 +116,42 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
            type == ASSERT_TRUE_METHOD || type == ASSERT_FALSE_METHOD;
   }
 
-  private String initTitle(@NotNull ConditionChecker.Type type) {
-    if (type.equals(IS_NULL_METHOD))
+  private static List<String> buildParameterClassListFromPsiMethod(PsiMethod psiMethod) {
+    List<String> parameterClasses = new ArrayList<String>();
+    PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+    for (PsiParameter param : parameters) {
+      PsiTypeElement typeElement = param.getTypeElement();
+      if (typeElement == null) return new ArrayList<String>();
+
+      PsiType psiType = typeElement.getType();
+
+      parameterClasses.add(psiType.getCanonicalText());
+    }
+    return parameterClasses;
+  }
+
+  private static String initTitle(@NotNull ConditionChecker.Type type) {
+    if (type.equals(IS_NULL_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.isNull.add.method.checker.dialog.title");
-    else if (type.equals(IS_NOT_NULL_METHOD))
+    }
+    else if (type.equals(IS_NOT_NULL_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.isNotNull.add.method.checker.dialog.title");
-    else if (type.equals(ASSERT_IS_NULL_METHOD))
+    }
+    else if (type.equals(ASSERT_IS_NULL_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.assert.isNull.add.method.checker.dialog.title");
-    else if (type.equals(ASSERT_IS_NOT_NULL_METHOD))
+    }
+    else if (type.equals(ASSERT_IS_NOT_NULL_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.assert.isNotNull.add.method.checker.dialog.title");
-    else if (type.equals(ASSERT_TRUE_METHOD))
+    }
+    else if (type.equals(ASSERT_TRUE_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.assert.true.add.method.checker.dialog.title");
-    else if (type.equals(ASSERT_FALSE_METHOD))
+    }
+    else if (type.equals(ASSERT_FALSE_METHOD)) {
       return InspectionsBundle.message("configure.checker.option.assert.false.add.method.checker.dialog.title");
-    else
+    }
+    else {
       throw new IllegalArgumentException("MethodCheckerDetailsDialog does not support type " + type);
+    }
   }
 
   @Override
@@ -135,29 +178,31 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
     return panel;
   }
 
-  MethodConditionCheck getMethodConditionChecker() {
+  @Nullable
+  ConditionChecker getConditionChecker() {
     return mySelectedChecker;
   }
 
-  private MethodConditionCheck buildMethodConditionChecker() {
+  @Nullable
+  private ConditionChecker buildConditionChecker() {
     PsiClass psiClass = classField.getPsiClass();
     PsiMethod psiMethod = methodDropDown.getSelectedPsiMethod();
     PsiParameter psiParameter = parameterDropDown.getSelectedPsiParameter();
     if (psiClass != null && psiMethod != null && psiParameter != null) {
-      return new MethodConditionCheck(psiMethod, psiParameter, myType);
-    } else {
+      return new ConditionChecker.FromPsiBuilder(psiMethod, psiParameter, myType).build();
+    }
+    else {
       return null;
     }
   }
 
-  private boolean overlaps() {
-    MethodConditionCheck thisChecker = buildMethodConditionChecker();
+  private boolean overlaps(ConditionChecker thisChecker) {
     for (ConditionChecker overlappingChecker : myOtherCheckers) {
       if (thisChecker.overlaps(overlappingChecker)) {
-        Messages.showMessageDialog(myProject,
-                                   InspectionsBundle.message("configure.checker.option.overlap.error.msg") + " " + overlappingChecker.toString(),
-                                   InspectionsBundle.message("configure.checker.option.overlap.error.title"),
-                                   Messages.getErrorIcon());
+        Messages.showMessageDialog(myProject, InspectionsBundle.message("configure.checker.option.overlap.error.msg") +
+                                              " " +
+                                              overlappingChecker.getConditionCheckType() + " " + overlappingChecker.toString(),
+                                   InspectionsBundle.message("configure.checker.option.overlap.error.title"), Messages.getErrorIcon());
         return true;
       }
     }
@@ -166,9 +211,7 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
 
   @Override
   public void propertyChange(PropertyChangeEvent evt) {
-//    if (evt.getPropertyName().equals(ClassField.PROPERTY_PSICLASS)) {
     checkOkActionEnable();
-//    }
   }
 
   @Override
@@ -177,23 +220,25 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
   }
 
   private void checkOkActionEnable() {
-    if (classField.getPsiClass() == null || methodDropDown.getSelectedPsiMethod() == null || parameterDropDown.getSelectedPsiParameter() == null) {
+    if (classField.getPsiClass() == null ||
+        methodDropDown.getSelectedPsiMethod() == null ||
+        parameterDropDown.getSelectedPsiParameter() == null) {
       setOKActionEnabled(false);
-    } else {
+    }
+    else {
       setOKActionEnabled(true);
     }
   }
 
   @Override
   protected void doOKAction() {
-    if (!overlaps()) {
-      MethodConditionCheck checker = buildMethodConditionChecker();
-      if (checker != null) {
-        if (checker.equals(myPreviouslySelectedChecker)) {
-          mySelectedChecker = myPreviouslySelectedChecker;
-        } else {
-          mySelectedChecker = checker;
-        }
+    ConditionChecker checker = buildConditionChecker();
+    if (checker != null && !overlaps(checker)) {
+      if (checker.equals(myPreviouslySelectedChecker)) {
+        mySelectedChecker = myPreviouslySelectedChecker;
+      }
+      else {
+        mySelectedChecker = checker;
       }
       super.doOKAction();
     }
@@ -204,35 +249,47 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
     PsiClass psiClass = classField.getPsiClass();
     PsiMethod psiMethod = methodDropDown.getSelectedPsiMethod();
     PsiParameter psiParameter = parameterDropDown.getSelectedPsiParameter();
-    if (psiClass == null || psiMethod == null || psiParameter == null)
+    if (psiClass == null || psiMethod == null || psiParameter == null) {
       return false;
-    else
+    }
+    else {
       return true;
+    }
   }
 
   /**
    * Input Text Field for Class Name
    */
   static class ClassField extends EditorTextFieldWithBrowseButton implements ActionListener, DocumentListener {
+    public static final String PROPERTY_PSICLASS = "ClassField.myPsiClass";
     private final @NotNull Project myProject;
     private @Nullable PsiClass myPsiClass;
-    public static final String PROPERTY_PSICLASS = "ClassField.myPsiClass";
 
     public ClassField(@NotNull Project project, @Nullable PsiClass psiClass) {
       super(project, true, buildVisibilityChecker());
       myProject = project;
       myPsiClass = psiClass;
-      setPreferredSize(new Dimension(500, (int) getPreferredSize().getHeight()));
-      if (myPsiClass != null)
+      setPreferredSize(new Dimension(500, (int)getPreferredSize().getHeight()));
+      if (myPsiClass != null) { //noinspection ConstantConditions
         setText(myPsiClass.getQualifiedName());
+      }
       addActionListener(this);
       getChildComponent().addDocumentListener(this);
     }
 
+    private static JavaCodeFragment.VisibilityChecker buildVisibilityChecker() {
+      return new JavaCodeFragment.VisibilityChecker() {
+        @Override
+        public Visibility isDeclarationVisible(PsiElement declaration, PsiElement place) {
+          return Visibility.VISIBLE;
+        }
+      };
+    }
+
     @Override
     public void actionPerformed(ActionEvent e) {
       final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject)
-        .createNoInnerClassesScopeChooser("Choose Class", new EverythingGlobalScope(myProject), new ClassFilter() {
+        .createNoInnerClassesScopeChooser("Choose Class", GlobalSearchScope.allScope(myProject), new ClassFilter() {
           @Override
           public boolean isAccepted(PsiClass aClass) {
             return !aClass.isAnnotationType();
@@ -240,8 +297,9 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
         }, null);
       chooser.showDialog();
       PsiClass psiClass = chooser.getSelected();
-      if (psiClass != null)
+      if (psiClass != null) { //noinspection ConstantConditions
         setText(chooser.getSelected().getQualifiedName());
+      }
     }
 
     @Nullable
@@ -258,7 +316,7 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       String className = event.getDocument().getText();
       PsiClass psiClass = null;
       if (className != null) {
-        psiClass = JavaPsiFacade.getInstance(myProject).findClass(className, new EverythingGlobalScope(myProject));
+        psiClass = JavaPsiFacade.getInstance(myProject).findClass(className, GlobalSearchScope.allScope(myProject));
       }
 
       if (psiClass != null && myPsiClass != null) {
@@ -266,38 +324,33 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
           firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
           myPsiClass = psiClass;
         }
-      } else if (psiClass != null) {
+      }
+      else if (psiClass != null) {
         firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
         myPsiClass = psiClass;
-      } else if (myPsiClass != null) {
+      }
+      else if (myPsiClass != null) {
         firePropertyChange(PROPERTY_PSICLASS, myPsiClass, psiClass);
         myPsiClass = null;
       }
     }
-
-    private static JavaCodeFragment.VisibilityChecker buildVisibilityChecker() {
-      return new JavaCodeFragment.VisibilityChecker() {
-        @Override
-        public Visibility isDeclarationVisible(PsiElement declaration, PsiElement place) {
-          return Visibility.VISIBLE;
-        }
-      };
-    }
   }
 
   /**
    * Drop Down for picking Method Name
    */
   static class MethodDropDown extends JComboBox implements PropertyChangeListener {
-    private @Nullable PsiClass myPsiClass;
     private final @NotNull ConditionChecker.Type myType;
     private final @NotNull SortedComboBoxModel<MethodWrapper> myModel;
+    private @Nullable PsiClass myPsiClass;
 
-    MethodDropDown(@Nullable PsiClass psiClass, @Nullable PsiMethod psiMethod, @NotNull ConditionChecker.Type type, SortedComboBoxModel<MethodWrapper> model) {
+    MethodDropDown(@Nullable PsiClass psiClass,
+                   @Nullable PsiMethod psiMethod,
+                   @NotNull ConditionChecker.Type type,
+                   @NotNull SortedComboBoxModel<MethodWrapper> model) {
       super(model);
 
-      if (!isSupported(type))
-        throw new IllegalArgumentException("Type is invalid " + type);
+      if (!isSupported(type)) throw new IllegalArgumentException("Type is invalid " + type);
 
       myPsiClass = psiClass;
       myType = type;
@@ -314,14 +367,37 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       }
     }
 
+    private static boolean isMethodFromJavaLangObject(PsiMethod method) {
+      if (method == null) return false;
+
+      PsiClass containingClass = method.getContainingClass();
+      if (containingClass == null) return false;
+      String name = containingClass.getQualifiedName();
+      if (name == null) return false;
+
+      if (CommonClassNames.JAVA_LANG_OBJECT.equals(name)) return true;
+
+      return false;
+    }
+
+    @NotNull
+    public static SortedComboBoxModel<MethodWrapper> buildModel() {
+      return new SortedComboBoxModel<MethodWrapper>(new Comparator<MethodWrapper>() {
+        @Override
+        public int compare(MethodWrapper o1, MethodWrapper o2) {
+          return o1.compareTo(o2);
+        }
+      });
+    }
+
     private void initValues() {
       if (myPsiClass != null) {
         myModel.clear();
         myModel.setSelectedItem(null);
         PsiMethod[] allMethods = myPsiClass.getAllMethods();
-        for (PsiMethod allMethod : allMethods) {
-          if (qualifies(allMethod))
-            myModel.add(new MethodWrapper(allMethod));
+        for (PsiMethod method : allMethods) {
+          MethodWrapper methodWrapper = new MethodWrapper(method);
+          if (qualifies(method) && !myModel.getItems().contains(methodWrapper)) myModel.add(methodWrapper);
         }
       }
     }
@@ -341,10 +417,10 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
         if (returnType != PsiType.BOOLEAN && (returnType == null || !returnType.getCanonicalText().equals(Boolean.class.toString()))) {
           return false;
         }
-      } else if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
+      }
+      else if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
         boolean booleanParamExists = false;
-        for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
-          PsiParameter psiParameter = psiMethod.getParameterList().getParameters()[i];
+        for (PsiParameter psiParameter : parameters) {
           PsiType type = psiParameter.getType();
           if (type.equals(PsiType.BOOLEAN) || type.getCanonicalText().equals(Boolean.class.toString())) {
             booleanParamExists = true;
@@ -362,24 +438,19 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       return true;
     }
 
-    private boolean isMethodFromJavaLangObject(PsiMethod method) {
-      if (method != null && method.getContainingClass() != null && method.getContainingClass().getName() != null &&
-          (method.getContainingClass().getName().equals("Object") || method.getContainingClass().getName().equals(Object.class.toString()))) {
-        return true;
-      }
-
-      return false;
-    }
-
+    /**
+     * Called when ClassField is set and when user selects entry in the MethodDropDown
+     */
     @Override
     public void propertyChange(PropertyChangeEvent evt) {
       if (evt.getPropertyName().equals(ClassField.PROPERTY_PSICLASS)) {
         if (evt.getNewValue() == null) {
           clear();
-        } else {
+        }
+        else {
           setEnabled(true);
           if (myPsiClass == null || !myPsiClass.equals(evt.getNewValue())) { // ClassChanged so refresh list
-            myPsiClass = (PsiClass) evt.getNewValue();
+            myPsiClass = (PsiClass)evt.getNewValue();
             initValues();
           }
         }
@@ -393,19 +464,10 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       myPsiClass = null;
     }
 
-    public static SortedComboBoxModel<MethodWrapper> buildModel() {
-      return new SortedComboBoxModel<MethodWrapper>(new Comparator<MethodWrapper>() {
-        @Override
-        public int compare(MethodWrapper o1, MethodWrapper o2) {
-          return o1.compareTo(o2);
-        }
-      });
-    }
-
+    @Nullable
     public PsiMethod getSelectedPsiMethod() {
       MethodWrapper methodWrapper = myModel.getSelectedItem();
-      if (methodWrapper == null)
-        return null;
+      if (methodWrapper == null) return null;
 
       return methodWrapper.getPsiMethod();
     }
@@ -415,16 +477,17 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
    * Drop Down for picking Parameter Name
    */
   static class ParameterDropDown extends JComboBox implements PropertyChangeListener, ItemListener {
-    private @Nullable PsiMethod myPsiMethod;
     private final @NotNull SortedComboBoxModel<ParameterWrapper> myModel;
     private final @NotNull ConditionChecker.Type myType;
-    public static final String PROPERTY_PARAMETERDROPDOWN = "ParameterDropDown.myModel";
+    private @Nullable PsiMethod myPsiMethod;
 
-    public ParameterDropDown(@Nullable PsiMethod psiMethod, @Nullable PsiParameter psiParameter, @NotNull SortedComboBoxModel<ParameterWrapper> model, @NotNull ConditionChecker.Type type) {
+    public ParameterDropDown(@Nullable PsiMethod psiMethod,
+                             @Nullable PsiParameter psiParameter,
+                             @NotNull SortedComboBoxModel<ParameterWrapper> model,
+                             @NotNull ConditionChecker.Type type) {
       super(model);
 
-      if (!isSupported(type))
-        throw new IllegalArgumentException("Type is invalid " + type);
+      if (!isSupported(type)) throw new IllegalArgumentException("Type is invalid " + type);
 
       myPsiMethod = psiMethod;
       myModel = model;
@@ -435,35 +498,16 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
         myModel.addAll(getParameterWrappers());
         if (psiParameter != null) {
           for (Iterator iterator = myModel.iterator(); iterator.hasNext(); ) {
-            ParameterWrapper wrapper = (ParameterWrapper) iterator.next();
-            if (wrapper.getPsiParameter().equals(psiParameter))
-              setSelectedItem(wrapper);
+            ParameterWrapper wrapper = (ParameterWrapper)iterator.next();
+            if (wrapper.getPsiParameter().equals(psiParameter)) setSelectedItem(wrapper);
           }
         }
-      } else {
+      }
+      else {
         setEnabled(false);
       }
     }
 
-    List<ParameterWrapper> getParameterWrappers() {
-      List<ParameterWrapper> wrappers = new ArrayList<ParameterWrapper>();
-      if (myPsiMethod != null) {
-        PsiParameterList parameterList = myPsiMethod.getParameterList();
-        for (int i = 0; i < parameterList.getParameters().length; i++) {
-          PsiParameter psiParameter = parameterList.getParameters()[i];
-          if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
-            PsiType type = psiParameter.getType();
-            if (type.equals(PsiType.BOOLEAN) || type.getCanonicalText().equals(Boolean.class.toString()))
-              wrappers.add(new ParameterWrapper(psiParameter, i));
-          } else {
-            wrappers.add(new ParameterWrapper(psiParameter, i));
-          }
-
-        }
-      }
-      return wrappers;
-    }
-
     public static SortedComboBoxModel<ParameterWrapper> buildModel() {
       return new SortedComboBoxModel<ParameterWrapper>(new Comparator<ParameterWrapper>() {
         @Override
@@ -473,10 +517,31 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       });
     }
 
+    List<ParameterWrapper> getParameterWrappers() {
+      List<ParameterWrapper> wrappers = new ArrayList<ParameterWrapper>();
+      if (myPsiMethod != null) {
+        PsiParameterList parameterList = myPsiMethod.getParameterList();
+        for (int i = 0; i < parameterList.getParameters().length; i++) {
+          PsiParameter psiParameter = parameterList.getParameters()[i];
+          if (myType == ASSERT_TRUE_METHOD || myType == ASSERT_FALSE_METHOD) {
+            PsiType type = psiParameter.getType();
+            if (type.equals(PsiType.BOOLEAN) || type.getCanonicalText().equals(Boolean.class.toString())) {
+              wrappers.add(new ParameterWrapper(psiParameter, i));
+            }
+          }
+          else {
+            wrappers.add(new ParameterWrapper(psiParameter, i));
+          }
+
+        }
+      }
+      return wrappers;
+    }
+
     @Override
     public void itemStateChanged(ItemEvent e) {
       if (e.getSource() instanceof MethodDropDown) { // The MethodDropDown has changed.
-        MethodDropDown methodDropDown = (MethodDropDown) e.getSource();
+        MethodDropDown methodDropDown = (MethodDropDown)e.getSource();
         if (methodDropDown.getSelectedPsiMethod() != null) {
           setEnabled(true);
           if (myPsiMethod == null || !myPsiMethod.equals(methodDropDown.getSelectedPsiMethod())) {
@@ -485,13 +550,15 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
             myModel.addAll(getParameterWrappers());
             myModel.setSelectedItem(null);
           }
-        } else {
+        }
+        else {
           myPsiMethod = null;
           myModel.clear();
           myModel.setSelectedItem(null);
           setEnabled(false);
         }
-      } else {
+      }
+      else {
         throw new RuntimeException("Unexpected Configuration ParameterDropDown is only expected to receive events from MethodDropDown.");
       }
     }
@@ -505,10 +572,10 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       }
     }
 
+    @Nullable
     public PsiParameter getSelectedPsiParameter() {
       ParameterWrapper parameterWrapper = myModel.getSelectedItem();
-      if (parameterWrapper == null)
-        return null;
+      if (parameterWrapper == null) return null;
 
       return parameterWrapper.getPsiParameter();
     }
@@ -525,10 +592,12 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
         PsiTypeElement typeElement = psiParameter.getTypeElement();
         if (typeElement == null) {
           typeName = "";
-        } else {
+        }
+        else {
           if (typeElement.getType() instanceof PsiPrimitiveType) {
-            typeName = ((PsiPrimitiveType) typeElement.getType()).getBoxedTypeName();
-          } else {
+            typeName = ((PsiPrimitiveType)typeElement.getType()).getBoxedTypeName();
+          }
+          else {
             typeName = typeElement.getType().getCanonicalText();
           }
         }
@@ -560,39 +629,40 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
     MethodWrapper(@NotNull PsiMethod psiMethod) {
       this.myPsiMethod = psiMethod;
 
-      List<String> parameters = new ArrayList<String>();
-      for (int i = 0; i < psiMethod.getParameterList().getParameters().length; i++) {
-        PsiParameter psiParameter = psiMethod.getParameterList().getParameters()[i];
-        parameters.add(getParameterQualifiedName(psiParameter));
+      List<String> parameterClassNames = new ArrayList<String>();
+      PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
+      for (PsiParameter psiParameter : parameters) {
+        parameterClassNames.add(getParameterQualifiedName(psiParameter));
       }
 
-      myId = initId(psiMethod.getName(), parameters);
+      myId = initId(psiMethod.getName(), parameterClassNames);
     }
 
-    private String getParameterQualifiedName(PsiParameter psiParameter) {
+    private static String getParameterQualifiedName(PsiParameter psiParameter) {
       PsiTypeElement typeElement = psiParameter.getTypeElement();
       if (typeElement == null) {
         return "";
       }
 
       if (typeElement.getType() instanceof PsiPrimitiveType) {
-        return ((PsiPrimitiveType) typeElement.getType()).getBoxedTypeName();
+        return ((PsiPrimitiveType)typeElement.getType()).getBoxedTypeName();
       }
 
       return typeElement.getType().getCanonicalText();
     }
 
-    private String initId(String methodName, List<String> parameterNames) {
+    private static String initId(String methodName, List<String> parameterNames) {
       String shortName = methodName + "(";
       for (String parameterName : parameterNames) {
-        if (parameterNames.lastIndexOf("") > -1)
-          shortName += parameterName.substring(parameterName.lastIndexOf("") + 1) + ", ";
-        else
+        if (parameterNames.lastIndexOf(".") > -1) {
+          shortName += parameterName.substring(parameterName.lastIndexOf(".") + 1) + ", ";
+        }
+        else {
           shortName += parameterName + ", ";
+        }
       }
 
-      if (parameterNames.size() > 0)
-        shortName = shortName.substring(0, shortName.lastIndexOf(", "));
+      if (parameterNames.size() > 0) shortName = shortName.substring(0, shortName.lastIndexOf(", "));
 
       shortName += ")";
       return shortName;
@@ -613,6 +683,23 @@ class MethodCheckerDetailsDialog extends DialogWrapper implements PropertyChange
       return myId;
     }
 
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      MethodWrapper that = (MethodWrapper)o;
+
+      if (!myId.equals(that.myId)) return false;
+
+      return true;
+    }
+
+    @Override
+    public int hashCode() {
+      return myId.hashCode();
+    }
+
     @Override
     public int compareTo(MethodWrapper o) {
       return myId.compareTo(o.myId);
diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
index fb8f28866961..82cfd3eec562 100644
--- a/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInspection/DataFlowInspectionTest.java
@@ -16,16 +16,14 @@
 package com.intellij.codeInspection;
 
 import com.intellij.JavaTestUtil;
-import com.intellij.codeInsight.ConditionCheckManager;
-import com.intellij.codeInsight.ConditionChecker;
-import com.intellij.codeInsight.MethodConditionCheck;
-import com.intellij.codeInsight.NullableNotNullManager;
+import com.intellij.codeInsight.*;
 import com.intellij.codeInspection.dataFlow.DataFlowInspection;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+import org.jetbrains.annotations.*;
 
 import java.io.IOException;
 
@@ -167,47 +165,48 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase {
 
   public void testIsNullCheck() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getIsNullCheckMethods().add(
-      buildMethodConditionCheck("Value", "isNull", ConditionChecker.Type.IS_NULL_METHOD,
-                                "public class Value { public static boolean isNull(Value o) {if (o == null) return true; else return false;} }"));
+      buildConditionChecker("Value", "isNull", ConditionChecker.Type.IS_NULL_METHOD,
+                            "public class Value { public static boolean isNull(Value o) {if (o == null) return true; else return false;} }"));
     doTest();
   }
 
   public void testIsNotNullCheck() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getIsNotNullCheckMethods().add(
-      buildMethodConditionCheck("Value", "isNotNull", ConditionChecker.Type.IS_NOT_NULL_METHOD,
-                                "public class Value { public static boolean isNotNull(Value o) {if (o == null) return false; else return true;} }"));
+      buildConditionChecker("Value", "isNotNull", ConditionChecker.Type.IS_NOT_NULL_METHOD,
+                            "public class Value { public static boolean isNotNull(Value o) {if (o == null) return false; else return true;} }"));
     doTest();
   }
 
   public void testAssertTrue() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getAssertTrueMethods().add(
-      buildMethodConditionCheck("Assertions", "assertTrue", ConditionChecker.Type.ASSERT_TRUE_METHOD,
-                                "public class Assertions { public static boolean assertTrue(boolean b) {if(!b) throw new Exception();} }"));
+      buildConditionChecker("Assertions", "assertTrue", ConditionChecker.Type.ASSERT_TRUE_METHOD,
+                            "public class Assertions { public static boolean assertTrue(boolean b) {if(!b) throw new Exception();} }"));
     doTest();
   }
 
   public void testAssertFalse() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getAssertFalseMethods().add(
-      buildMethodConditionCheck("Assertions", "assertFalse", ConditionChecker.Type.ASSERT_FALSE_METHOD,
-                                "public class Assertions { public static boolean assertFalse(boolean b) {if(b) throw new Exception();} }"));
+      buildConditionChecker("Assertions", "assertFalse", ConditionChecker.Type.ASSERT_FALSE_METHOD,
+                            "public class Assertions { public static boolean assertFalse(boolean b) {if(b) throw new Exception();} }"));
     doTest();
   }
 
   public void testAssertIsNull() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getAssertIsNullMethods().add(
-      buildMethodConditionCheck("Assertions", "assertIsNull", ConditionChecker.Type.ASSERT_IS_NULL_METHOD,
-                                "public class Assertions { public static boolean assertIsNull(Object o) {if(o != null) throw new Exception();} }"));
+      buildConditionChecker("Assertions", "assertIsNull", ConditionChecker.Type.ASSERT_IS_NULL_METHOD,
+                            "public class Assertions { public static boolean assertIsNull(Object o) {if(o != null) throw new Exception();} }"));
     doTest();
   }
 
   public void testAssertIsNotNull() throws Exception {
     ConditionCheckManager.getInstance(myModule.getProject()).getAssertIsNotNullMethods().add(
-      buildMethodConditionCheck("Assertions", "assertIsNotNull", ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD,
-                                "public class Assertions { public static boolean assertIsNotNull(Object o) {if(o == null) throw new Exception();} }"));
+      buildConditionChecker("Assertions", "assertIsNotNull", ConditionChecker.Type.ASSERT_IS_NOT_NULL_METHOD,
+                            "public class Assertions { public static boolean assertIsNotNull(Object o) {if(o == null) throw new Exception();} }"));
     doTest();
   }
 
-  private MethodConditionCheck buildMethodConditionCheck(String className, String methodName, ConditionChecker.Type type, String classText)
+  @Nullable
+  private ConditionChecker buildConditionChecker(String className, String methodName, ConditionChecker.Type type, String classText)
     throws IOException {
     myFixture.addClass(classText);
     PsiClass psiClass = myFixture.findClass(className);
@@ -219,6 +218,7 @@ public class DataFlowInspectionTest extends LightCodeInsightFixtureTestCase {
         break;
       }
     }
-    return new MethodConditionCheck(psiMethod, psiMethod.getParameterList().getParameters()[0], type);
+    assert psiMethod != null;
+    return new ConditionChecker.FromPsiBuilder(psiMethod, psiMethod.getParameterList().getParameters()[0], type).build();
   }
 }

From c64013e0040e9b0b9021a85a7c29e7c9864fd79b Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 16:04:21 +0100
Subject: [PATCH 285/354] lambda: check more specific method based on lambda
 return types

---
 .../src/com/intellij/psi/LambdaUtil.java      | 33 ++++++--
 .../intellij/psi/util/TypeConversionUtil.java |  3 +
 .../JavaMethodsConflictResolver.java          |  5 +-
 .../AmbiguityReturnValueResolution1.java      | 82 +++++++++++++++++++
 .../daemon/lambda/LambdaHighlightingTest.java |  4 +
 5 files changed, 115 insertions(+), 12 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution1.java

diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
index 1c91e6e8066e..672f290abbdc 100644
--- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
@@ -636,22 +636,39 @@ public class LambdaUtil {
     return result;
   }
 
-  public static void checkMoreSpecificReturnType(List<CandidateInfo> conflicts, int functionalInterfaceIdx) {
+  public static void checkMoreSpecificReturnType(List<CandidateInfo> conflicts, PsiType[] actualParameterTypes) {
     final CandidateInfo[] newConflictsArray = conflicts.toArray(new CandidateInfo[conflicts.size()]);
     for (int i = 1; i < newConflictsArray.length; i++) {
       final CandidateInfo method = newConflictsArray[i];
-      final PsiType interfaceReturnType = getReturnType(functionalInterfaceIdx, method);
       for (int j = 0; j < i; j++) {
         final CandidateInfo conflict = newConflictsArray[j];
         assert conflict != method;
-        final PsiType interfaceReturnType1 = getReturnType(functionalInterfaceIdx, conflict);
-        if (interfaceReturnType != null && interfaceReturnType1 != null && !Comparing.equal(interfaceReturnType, interfaceReturnType1)) {
-          int moreSpecific = isMoreSpecific(interfaceReturnType, interfaceReturnType1);
-          if (moreSpecific > 0) {
+        int moreSpecific = 0;
+        final PsiMethod methodElement = (PsiMethod)method.getElement();
+        final PsiMethod conflictElement = (PsiMethod)conflict.getElement();
+        if (methodElement.isVarArgs() == conflictElement.isVarArgs()) {
+          for (int functionalInterfaceIdx = 0; functionalInterfaceIdx < actualParameterTypes.length; functionalInterfaceIdx++) {
+            final PsiType interfaceReturnType = getReturnType(functionalInterfaceIdx, method);
+            final PsiType interfaceReturnType1 = getReturnType(functionalInterfaceIdx, conflict);
+            if (actualParameterTypes[functionalInterfaceIdx] instanceof PsiLambdaExpressionType || actualParameterTypes[functionalInterfaceIdx] instanceof PsiMethodReferenceType) {
+              if (interfaceReturnType != null && interfaceReturnType1 != null && !Comparing.equal(interfaceReturnType, interfaceReturnType1)) {
+                int moreSpecific1 = isMoreSpecific(interfaceReturnType, interfaceReturnType1);
+                if (moreSpecific < 0 && moreSpecific1 > 0 || moreSpecific > 0 && moreSpecific1 < 0) {
+                  moreSpecific = 0;
+                  break;
+                }
+                moreSpecific = moreSpecific1;
+              }
+            } else if (interfaceReturnType != null && interfaceReturnType1 != null) {
+              moreSpecific = 0;
+              break;
+            }
+          }
+          if (moreSpecific > 0 && conflictElement.getParameterList().getParametersCount() <= actualParameterTypes.length) {
             conflicts.remove(method);
             break;
           }
-          else if (moreSpecific < 0) {
+          else if (moreSpecific < 0 && methodElement.getParameterList().getParametersCount() <= actualParameterTypes.length) {
             conflicts.remove(conflict);
           }
         }
@@ -665,7 +682,7 @@ public class LambdaUtil {
       if (!(returnType1 instanceof PsiPrimitiveType)) {
         return -1;
       } else {
-        return TypeConversionUtil.areTypesConvertible(returnType, returnType1) ? 1 : -1;
+        return TypeConversionUtil.isAssignable(returnType, returnType1) ? 1 : -1;
       }
     }
     if (returnType1 instanceof PsiPrimitiveType) {
diff --git a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
index a44600573970..09ef657b4c4a 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/TypeConversionUtil.java
@@ -686,6 +686,9 @@ public class TypeConversionUtil {
         final PsiType lType = lLambdaExpression.getFunctionalInterfaceType();
         return Comparing.equal(rType, lType);
       }
+      if (left instanceof PsiArrayType) {
+        return false;
+      }
       return LambdaUtil.isAcceptable(rLambdaExpression, left, false);
     }
 
diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
index 7501526a3d69..b8141babaa3f 100644
--- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
+++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java
@@ -126,12 +126,9 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{
             }
           }
         }
-        LambdaUtil.checkMoreSpecificReturnType(conflicts, i);
-      }
-      else if (parameterType instanceof PsiMethodReferenceType) {
-        LambdaUtil.checkMoreSpecificReturnType(conflicts, i);
       }
     }
+    LambdaUtil.checkMoreSpecificReturnType(conflicts, myActualParameterTypes);
   }
 
   public void checkSpecifics(List<CandidateInfo> conflicts, @MethodCandidateInfo.ApplicabilityLevelConstant int applicabilityLevel) {
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution1.java
new file mode 100644
index 000000000000..fab979466120
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution1.java
@@ -0,0 +1,82 @@
+public class Test {
+
+        interface II {
+            int _();
+        }
+
+        interface IL {
+            long _();
+        }
+
+        void m0(II im) { }
+        void m0(IL lm) { }
+
+        {
+            m0(() -> 1);
+            m0<error descr="Ambiguous method call: both 'Test.m0(II)' and 'Test.m0(IL)' match">(null)</error>;
+        }
+
+        void m(II im, IL s) { }
+        void m(IL lm, II s) { }
+
+        {
+            m<error descr="Ambiguous method call: both 'Test.m(II, IL)' and 'Test.m(IL, II)' match">(() -> 1,  () ->1)</error>;
+        }
+
+
+        void m1(II im, Object s) { }
+        void m1(IL lm, Object s) { }
+
+        {
+            m1(() -> 1, null);
+            m1(() -> 1, "");
+        }
+
+        void m2(II im1, II... im) { }
+        void m2(IL... lm) { }
+
+
+        void mi(int im1, int... im) { }
+        void mi(long... lm) { }
+
+         {
+            mi (1);
+            m2();
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1)</error>;
+            m2(()->1, ()->1);
+            m2(()->1, ()->1, ()->1);
+
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, null, null)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, null, null)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, ()->1, null)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, null, ()->1)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, ()->1, null)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, ()->1, ()->1)</error>;
+            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, null, ()->1)</error>;
+
+            m2(()->1L, null, null);
+            m2(null, ()->1L, null);
+            m2(null, null, ()->1L);
+            m2(()->1L, ()->1L, null);
+            m2(null, ()->1L, ()->1L);
+            m2(()->1L, null, ()->1L);
+            m2(()->1L, ()->1L, ()->1L);
+         }
+
+        void m3(II... im) {}
+        void m3(IL... lm) {}
+
+        {
+            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">()</error>;
+            m3(() -> 1);
+            m3(() -> 1, () -> 1);
+            m3(() -> 1, () -> 1, () -> 1);
+
+            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(null, null)</error>;
+            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(() -> 1,  null)</error>;
+            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(null, () -> 1)</error>;
+            m3(() -> 1L, null);
+            m3(null, () -> 1L);
+        }
+
+}
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 03973993d10a..695bcdb92adf 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -208,6 +208,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testAmbiguityReturnValueResolution1() throws Exception {
+    doTest();
+  }
+
   public void testLambdaOnVarargsPlace1() throws Exception {
     doTest();
   }

From 1ea31abaa3545a21def2604719f26dc2d398b753 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 14:02:14 +0100
Subject: [PATCH 286/354] IDEA-101843 Seems "Super Method" action can be dumb
 aware

---
 .../navigation/actions/GotoSuperAction.java          | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
index 13f75d480460..f74f9b7ea493 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoSuperAction.java
@@ -22,6 +22,9 @@ import com.intellij.lang.CodeInsightActions;
 import com.intellij.lang.Language;
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.DumbService;
+import com.intellij.openapi.project.IndexNotReadyException;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
@@ -29,7 +32,7 @@ import com.intellij.psi.util.PsiUtilBase;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
-public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsightActionHandler {
+public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsightActionHandler, DumbAware {
 
   @NonNls public static final String FEATURE_ID = "navigation.goto.super";
 
@@ -48,7 +51,12 @@ public class GotoSuperAction extends BaseCodeInsightAction implements CodeInsigh
 
     final CodeInsightActionHandler codeInsightActionHandler = CodeInsightActions.GOTO_SUPER.forLanguage(language);
     if (codeInsightActionHandler != null) {
-      codeInsightActionHandler.invoke(project, editor, file);
+      try {
+        codeInsightActionHandler.invoke(project, editor, file);
+      }
+      catch (IndexNotReadyException e) {
+        DumbService.getInstance(project).showDumbModeNotification("Goto Super action is not available during indexing");
+      }
     }
   }
 

From a917796bb2b348d3a35bd76b1eb79b643430a65a Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 14:58:36 +0100
Subject: [PATCH 287/354] commitDocument exceptions shouldn't fail the entire
 save (IDEA-101980)

---
 .../src/com/intellij/psi/impl/PsiDocumentManagerImpl.java  | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
index 05a59804171a..93a2277cc51d 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
@@ -819,7 +819,12 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec
     // Ensure all documents are committed on save so file content dependent indices, that use PSI to build have consistent content.
     UIUtil.invokeLaterIfNeeded(new Runnable() {
       public void run() {
-        commitAllDocuments();
+        try {
+          commitAllDocuments();
+        }
+        catch (Exception e) {
+          LOG.error(e);
+        }
       }
     });
   }

From 9048062500cf63d7338dcf8031bc5ccd003d23de Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Wed, 27 Feb 2013 16:46:03 +0100
Subject: [PATCH 288/354] IDEA-100595 Allow to set grape.root

---
 .../jps/incremental/groovy/GroovyBuilder.java      | 14 +++++++++++---
 .../groovy/GroovycOSProcessHandler.java            |  1 +
 .../groovy/runner/DefaultGroovyScriptRunner.java   |  8 ++++++++
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java
index 495775080b2a..8df50c2fdabd 100644
--- a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java
+++ b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java
@@ -173,13 +173,21 @@ public class GroovyBuilder extends ModuleLevelBuilder {
       programParams.add("--indy");
     }
 
+    List<String> vmParams = ContainerUtilRt.newArrayList();
+    vmParams.add("-Xmx" + settings.heapSize + "m");
+    vmParams.add("-Dfile.encoding=" + System.getProperty("file.encoding"));
+    //vmParams.add("-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5239");
+
+    String grapeRoot = System.getProperty(GroovycOSProcessHandler.GRAPE_ROOT);
+    if (grapeRoot != null) {
+      vmParams.add("-D" + GroovycOSProcessHandler.GRAPE_ROOT + "=" + grapeRoot);
+    }
+
     final List<String> cmd = ExternalProcessUtil.buildJavaCommandLine(
       getJavaExecutable(chunk),
       "org.jetbrains.groovy.compiler.rt.GroovycRunner",
       Collections.<String>emptyList(), classpath,
-      Arrays.asList("-Xmx" + settings.heapSize + "m",
-                    "-Dfile.encoding=" + System.getProperty("file.encoding")/*,
-                    "-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5239"*/),
+      vmParams,
       programParams
     );
 
diff --git a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovycOSProcessHandler.java b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovycOSProcessHandler.java
index f99d1ade7a82..38d3ae233e72 100644
--- a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovycOSProcessHandler.java
+++ b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovycOSProcessHandler.java
@@ -40,6 +40,7 @@ import java.util.*;
  */
 public class GroovycOSProcessHandler extends BaseOSProcessHandler {
   public static final String GROOVY_COMPILER_IN_OPERATION = "Groovy compiler in operation...";
+  public static final String GRAPE_ROOT = "grape.root";
   private final List<OutputItem> myCompiledItems = new ArrayList<OutputItem>();
   private final Set<File> toRecompileFiles = new HashSet<File>();
   private final List<CompilerMessage> compilerMessages = new ArrayList<CompilerMessage>();
diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/runner/DefaultGroovyScriptRunner.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/runner/DefaultGroovyScriptRunner.java
index a6cc7fb7b9ef..7bd62c3bb8ba 100644
--- a/plugins/groovy/src/org/jetbrains/plugins/groovy/runner/DefaultGroovyScriptRunner.java
+++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/runner/DefaultGroovyScriptRunner.java
@@ -35,6 +35,7 @@ import com.intellij.openapi.vfs.encoding.EncodingProjectManager;
 import com.intellij.util.net.HttpConfigurable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.incremental.groovy.GroovycOSProcessHandler;
 import org.jetbrains.plugins.groovy.util.GroovyUtils;
 import org.jetbrains.plugins.groovy.util.LibrariesUtil;
 
@@ -109,6 +110,13 @@ public class DefaultGroovyScriptRunner extends GroovyScriptRunner {
 
     params.getProgramParametersList().add("--main");
     params.getProgramParametersList().add(mainClass);
+
+    if (params.getVMParametersList().getPropertyValue(GroovycOSProcessHandler.GRAPE_ROOT) == null) {
+      String sysRoot = System.getProperty(GroovycOSProcessHandler.GRAPE_ROOT);
+      if (sysRoot != null) {
+        params.getVMParametersList().defineProperty(GroovycOSProcessHandler.GRAPE_ROOT, sysRoot);
+      }
+    }
   }
 
   private static void addScriptEncodingSettings(final JavaParameters params, final VirtualFile scriptFile, Module module) {

From 5e589b9e555e3121e6834499ec0af8fbce697670 Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Wed, 27 Feb 2013 20:00:30 +0400
Subject: [PATCH 289/354] EA-41296 - assert:
 FocusManagerImpl.isFocusTransferReady

---
 .../org/jetbrains/idea/maven/wizards/MavenProjectBuilder.java | 4 +++-
 .../jetbrains/idea/maven/wizards/MavenProjectImportStep.java  | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectBuilder.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectBuilder.java
index a3a21b5199e1..a516632a38ca 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectBuilder.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectBuilder.java
@@ -135,11 +135,13 @@ public class MavenProjectBuilder extends ProjectImportBuilder<MavenProject> {
                                   : new MavenDefaultModifiableModelsProvider(project));
   }
 
-  public boolean setRootDirectory(final String root) throws ConfigurationException {
+  public boolean setRootDirectory(@Nullable Project projectToUpdate, final String root) throws ConfigurationException {
     getParameters().myFiles = null;
     getParameters().myProfiles.clear();
     getParameters().myMavenProjectTree = null;
 
+    getParameters().myProjectToUpdate = projectToUpdate; // We cannot determinate project in non-EDT thread.
+
     return runConfigurationProcess(ProjectBundle.message("maven.scanning.projects"), new MavenTask() {
       public void run(MavenProgressIndicator indicator) throws MavenProcessCanceledException {
         indicator.setText(ProjectBundle.message("maven.locating.files"));
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectImportStep.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectImportStep.java
index 39fca0a4efc1..632663e077b5 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectImportStep.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/wizards/MavenProjectImportStep.java
@@ -102,7 +102,7 @@ public class MavenProjectImportStep extends ProjectImportWizardStep {
 
   public boolean validate() throws ConfigurationException {
     updateDataModel(); // needed to make 'exhaustive search' take an effect.
-    return getBuilder().setRootDirectory(myRootPathComponent.getPath());
+    return getBuilder().setRootDirectory(getWizardContext().getProject(), myRootPathComponent.getPath());
   }
 
   public void updateStep() {

From dcc8f19fd45df575c0cc6beffba5096667fca0a7 Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Wed, 27 Feb 2013 20:03:34 +0400
Subject: [PATCH 290/354] Remove dead code.

---
 .../idea/maven/indices/MavenProjectIndicesManager.java          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenProjectIndicesManager.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenProjectIndicesManager.java
index cd62356c6ea2..fecc4e147c5f 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenProjectIndicesManager.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenProjectIndicesManager.java
@@ -109,7 +109,7 @@ public class MavenProjectIndicesManager extends MavenSimpleProjectComponent {
     for (MavenRemoteRepository each : getMavenProjectManager().getRemoteRepositories()) {
       String id = each.getId();
       String url = each.getUrl();
-      if (id == null || url == null) continue;
+
       result.add(Pair.create(id, url));
     }
     return result;

From 340f34b50ab39a0da039e4a5bb8f2985edd25d8f Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Wed, 27 Feb 2013 20:19:07 +0400
Subject: [PATCH 291/354] EA-38687 - NPE: MavenIndex.hasArtifactId

---
 .../java/org/jetbrains/idea/maven/indices/MavenIndex.java   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java
index ac81fea6270d..dd1e26f55302 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java
@@ -500,14 +500,20 @@ public class MavenIndex {
   }
 
   public synchronized boolean hasGroupId(String groupId) {
+    if (isBroken) return false;
+
     return hasValue(myData.groupToArtifactMap, myData.hasGroupCache, groupId);
   }
 
   public synchronized boolean hasArtifactId(String groupId, String artifactId) {
+    if (isBroken) return false;
+
     return hasValue(myData.groupWithArtifactToVersionMap, myData.hasArtifactCache, groupId + ":" + artifactId);
   }
 
   public synchronized boolean hasVersion(String groupId, String artifactId, final String version) {
+    if (isBroken) return false;
+
     final String groupWithArtifactWithVersion = groupId + ":" + artifactId + ':' + version;
 
     Boolean res = myData.hasVersionCache.get(groupWithArtifactWithVersion);

From 329607d9ebcedf2bb0ad81265354366db7dc3f9c Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 17:29:25 +0100
Subject: [PATCH 292/354] retina quality for groupBy icons

---
 platform/icons/src/actions/GroupByModule@2x.png   | Bin 0 -> 646 bytes
 .../icons/src/actions/GroupByModule@2x_dark.png   | Bin 0 -> 659 bytes
 platform/icons/src/actions/GroupByPrefix.png      | Bin 0 -> 350 bytes
 platform/icons/src/actions/GroupByPrefix@2x.png   | Bin 0 -> 712 bytes
 .../icons/src/actions/GroupByPrefix@2x_dark.png   | Bin 0 -> 731 bytes
 platform/icons/src/actions/GroupByPrefix_dark.png | Bin 0 -> 329 bytes
 .../src/actions/moveToAnotherChangelist@2x.png    | Bin 0 -> 896 bytes
 .../actions/moveToAnotherChangelist@2x_dark.png   | Bin 0 -> 893 bytes
 .../src/actions/moveToAnotherChangelist_dark.png  | Bin 0 -> 494 bytes
 9 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/actions/GroupByModule@2x.png
 create mode 100644 platform/icons/src/actions/GroupByModule@2x_dark.png
 create mode 100644 platform/icons/src/actions/GroupByPrefix.png
 create mode 100644 platform/icons/src/actions/GroupByPrefix@2x.png
 create mode 100644 platform/icons/src/actions/GroupByPrefix@2x_dark.png
 create mode 100644 platform/icons/src/actions/GroupByPrefix_dark.png
 create mode 100644 platform/icons/src/actions/moveToAnotherChangelist@2x.png
 create mode 100644 platform/icons/src/actions/moveToAnotherChangelist@2x_dark.png
 create mode 100644 platform/icons/src/actions/moveToAnotherChangelist_dark.png

diff --git a/platform/icons/src/actions/GroupByModule@2x.png b/platform/icons/src/actions/GroupByModule@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..9bc43c61cd55c52b6e738cb9a96f486b9aeb9f23
GIT binary patch
literal 646
zcmV;10(t$3P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!C`m*?RCwCtmrW={Q547D7#}l3LI~Md
zNWzXCR<f}okp)>PBW0mb*dR*Ef=O9eC?sVmWnm#3c7~OFEPR#O$aiz^^M5)|&$vA9
zyOZM7uQPLJ?!Eta?mhRO=hAgu`%R0{e%WHp4}QPj+TIPu!7ONVIL91l1$|)5Yzzbf
zpGKgX{<sS|6+C1I2!dfyW48nuU>@9qM)0ISfH~GPjh*|IfKiYM2EmcSr9J>7AQen}
zCLjm2fJ-nFh5a@Ou0cJ>7YV2XabO8NMnS+GSf)7}K4bx`g8Zhn*Ku;0qk|&vX2)gu
zx?v<7C>IGRAs@63;PHAjx7#f>Ib%%IZr(NRkuMYp$R>Yb?U9<6rg?onDFF}nNPw$%
zP3PpZL;_MQY4c|B9*^ctloP->7p0_O2_gYP<G3rB<b7fEwL9x=1%$c&ii{ckVx0<L
zIv0iVdrP3(_p=w^AOh?g{p^<jPZ8GTA`n&)0jGPwu>j8H_W<XAAp*wJhh?+ihY`31
zNx)}44cTitNoK*vCi6&r5DB=Td)lZA4y~!g)TN<$-<*l+fnda~_;#E+A;OBu?~5X^
z4QfFZST!39PS;!ti;_z6TcQZ8(6SlTN@5f$qIl3mbF7F2oPb4;4!WWspq=)>0?j3?
zio2*N?FU5)C(i>zAOw28D$7Ik7GoBtK1HElrm>nMD=tyJunu}@$4)B{Fa=7%09cFs
g(e>}&j$Z^A0Cl11*)~%=mH+?%07*qoM6N<$f@~WTmH+?%

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/GroupByModule@2x_dark.png b/platform/icons/src/actions/GroupByModule@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..10d000d2b5f035dbe9b50934ee7e0a468a46dfcf
GIT binary patch
literal 659
zcmV;E0&M+>P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!HAzH4RCwBA{Qv(y!$1Nih5-gFFvk4(
z^O40%fVdloXP-WOI*k$wOifKe1}6Y<B@lPO#1j(}afW~!RN)yQ&ZUAUvw`>u5Vrua
zH=!sH1>(g({0)f1f%qpC8~`)x7u0MSd=6*_Vlg1D1LAvBjOuGZ+zP~kK-`PV0a8F5
z2gEOccm@s9+XNtf1H>UftcuM6K|st3#4CXK2MrwX6^K_s?F_@n1wdd6r4JzMy3c1y
zQ9)tKz`%&a-2=o~Kx~7}0lHB73bFwloSY2I%*<q2{`c=+Ao(3x=rWYn#O44=DE%B+
zhoF!U11A?3Sq}LA4U_?%A`3l((h}GlAb^x@;DC*TgMpKqJO}*!_YYf^1Oawz4!{cj
z0qcstWY!n|h|ovS0e}Ae2V-&oG5QEP;P3x`*n*O{DER-63J#zk1pZPZ1pWYh@#jBz
zA@GM9Au!-+;NL&;)4;!f!yyDfzW+mRE+8=kz5p=~5OX1yhJV4?iOgJpDFiE0zhiU2
zb7(ycY8Tu=&Pso&mknX{%~Ndcfh%aWBD^@I1fu~RD18-M2pj|AKp=Jj;`J~=^@rOT
zDQbp@nIiM-p!5-JA+QD-ZJ^c)Hw{`uY(N|dwPOu72Rs1c<v=U~#04~PKqfQ|EQ8vG
zwN+dIZIspku{ISgR|Mi_AbtzP<@lQAZ=t;ySmTt7N<qI0YE~?Iiwj%NXeSU?KvV2g
tDmY*Y5SsvTEf8-<mt-9Ay<>m?0|5O@>vrxc)5!n;002ovPDHLkV1n<+3g7?$

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/GroupByPrefix.png b/platform/icons/src/actions/GroupByPrefix.png
new file mode 100644
index 0000000000000000000000000000000000000000..c8754bc3570b51a45d3af1d6f8dcb299e38c379b
GIT binary patch
literal 350
zcmV-k0iphhP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz07*naRCwB?Q?UxdFc5udR7iAi6v5rq
zMg0oVwI5g<{RY877gwF!#IaJaBF31ssU)^)z=I><a_{BdB}b%`_{WGQ2*XhChsqbq
zyFV~T<x}OGD2fo6pf4CEXJIg?nV>J&Cef92Yj$+fyGlx_lPQG2GU<?ahB%I4SCAR!
z0*u$4#Po6ll5DHHO{}#{FyA*xx!NY$?Y!Yd<Ly(2U^fslpn(H_hzG_8kWbBU2+lkO
z<qfw7S^_*Jj8?6Rn-rn1glm6N`3g8K{Uk`nK^b!r?rG{Tfo<odn=-om8NN!G6+f%0
w%;M9$&4b3gW?^lSz+;$Z29r<YKlT)0076AgDU$Uzf&c&j07*qoM6N<$f(ql5WdHyG

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/GroupByPrefix@2x.png b/platform/icons/src/actions/GroupByPrefix@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..d602305eea682bbe79565e4cf2b79a5f0adf4d68
GIT binary patch
literal 712
zcmV;(0yq7MP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!YDq*vRCwBA{Qv(y!$1Nih5-gFFh*8Z
z7P5FP5H|twBp}YG(2nIm90A0IKs*5^IBnWAoFU)^#En3F6o^Zy;K?)~z6r!VK<rE?
z3Z#H|F%W+M;wT{gMFj_Z2I4p%1|_ydKrDpM0bNi9)j<4+icx(Eh`XU4?8D^%1!!D>
zES^Jy^wtT)AAvX;h~=?4AOwh+fp`TF|E7ThK$fqCCj4NGTmS?%P<kJTFk!k!QUP)1
zpAsVx%Ju+p64b6fbO&fd>B}I3jh&f+nVFd=%m4oU%fRrRD5aO6v<|iqkcOtzS0D}_
z9}5E~7Y9+Me*g9Z*#U>4v@I6?ODJ0sn*%tZ@$?5Q!Tghfot2R&2mA)AMFTcC_^`Ca
zgUtabV9PTlMlutdEgt@#fvyX_;;akM!6EUdB;^9Tm(pZ~7)}TLW&6j#NMtVf56T6U
z)`sZd7at=7GZzbS+3?#xWG=p3K)eG!vV3D;V*5js1OEN`MQko0-T`43)o76m2E0YY
zM05z;=QAZK7bt!@O-zXK;&Z?cPzekb`@_t}Mp|7!9AJggAFw&#CA6Lv2jZu!yu1wT
zoSa0N`tv)mB6veoE)a*ZpJQ{t4X6WjK@RxE$jrdR!bX$>elZfA3s7oYbO(T3>JG%N
zK)gf#-d0-V0w=UkK}nUXq1ACD5OdHV2XI1LLcgIcBMb-J0^&8$x;lpj4#)#y5g=ZO
zoCcV%C;}y?dLUM#qUGv9Tmwz$mG}yV7eJf{#N5!vDLWM`=YpEW3GHjVAyg7>frfw~
u5cgBT0n>rl0NTsihc3xD;(Nyc0R{lHyN(7@lCll}0000<MNUMnLSTXd&nGGX

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/GroupByPrefix@2x_dark.png b/platform/icons/src/actions/GroupByPrefix@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..e0d28fea3d585fd0387a2ea5f5ffbd52cade721d
GIT binary patch
literal 731
zcmV<10wn#3P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!eMv+?RCwCtmpy0{K@`VlcJ}tNr+0-2
zhe}WcW1)hA=@J$c5o{ID4+v;s6%-2#(I82uhA1{Rf~bWaYL~)70%x$XQyaArgs71e
z2}$mfy)XYG@8aENcki9-a)krGov&r)zccU6o0au?U34=UqRYu_6!Q6ebNdJw1NXos
z-B2hLLI-jjC#dTwI0Y_)yN$+NE*H20$G|9f3$8@)kr%*cFb)p4+k&m&377|GfE$5;
zMKA=ku{{Qx!UWu+7p{SC5pMN6aGO4GB1pgv+ABTrgBa}XCRhMx!FE3ZCx8OaKsg2h
zdh(ZK_{Z0I0nz~FQ~I$y{jlYLIM~)<9mx>!8l0!OCcFanQ2tRrtfUf3Db}Y|t5xnQ
ze4u=<-wJFaOZ}xQnT#pyR1a&^QgKC;{#K_cAM~luQhAG?0Gsxy@~1<siey5v1eEcv
zCk+JD8@9F4Pe4nW{Jv9mVqwm%wc?<stGQn3b}U#9j0N8GCOgwnm_#Iy|Dq^RK-H=V
z$@GFc-wXHx+>8_|W%AsxSZl6^c>!O*f>{)XRbdIJxh~fW_ySJ8@9S(&9hMh#{YGT4
zSKw==KMpTQhY48GCor{Dlx4*c3lfyi`w5t(IGqJEiF8^dZJRafYDq_e62}X&RQ};7
z;1dbhrv<oD3B$Bl0$j=Vf|iKu6`++K1xLWEq249z>C#$fyIZm7bvRyd$g?UfR{5O5
z@oCT#g9q4j6DrfqXq|vB;049%;TQy51e?L5W*abkUYY|pKwpHD?*`Y&(65Fa3_rm+
zuz@b8$p|J-(O5S9Ys|Gf2`6a<4uCrm2)GaS(_hw<w^RQ2f5*QC7yt<IkvCh%^%npD
N002ovPDHLkV1fZbLO=ij

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/GroupByPrefix_dark.png b/platform/icons/src/actions/GroupByPrefix_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a02c8f2115f35358de50ca6c9db2d36aa0f25788
GIT binary patch
literal 329
zcmV-P0k-~$P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUy>q$gGRCwB?Q!x^PFc7>DbSA+UP*~Gy
zp}!EV;uEFg6Bbxl>j&s<jN=$$z{DXEG>kX1gbBBs+q;0Il<-f4^&`u&dRZvs3h@t4
zsjyZ!FvcLzo4#bwIl1P%Di}a+i`13GVS85|Gl?;_GKCO;<_vx9feA_l5IV9F`1KB4
z>notv+7;NHBgaV*q)GE)zM<X<PBS3`99Z;9RFHm<dIc_&1EyoU2g(BYT3GHUj+2yN
z>S^JYtejH-Ukj2@z=T){4_?oJ`&rmdIRZ1ZZa6KNmT&aU@{Lk+-U7t{5koGTa{m3D
bp8^a33>`!r5D*BG00000NkvXXu0mjf0q255

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/moveToAnotherChangelist@2x.png b/platform/icons/src/actions/moveToAnotherChangelist@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..b00ac4b0af40d824523649b2ba627c418dd56a91
GIT binary patch
literal 896
zcmV-`1AqL9P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#B1uF+RCwCNS4~J%Q4~J+{mi^^bS5Xs
zh*~%m{Sb&jq?krOMny$I?TZ$z5?a_QTSTpd7P%|j1VO7>2pN`^{fTACh>0~wGGLRX
z_&bs_@7>$EZ{C1T^Lq2%%;bTO`~L1d-#Pc(bIv1-F|Z>oEiI`_dlS>7si}$ZQGitz
zDGzH9o8Pm%5*Qd5$oku=s;a-9<#P*e8rGR1qvVsoHN-8ulky#ewn-G?6tp5HSBpS7
zq8m|$_+{%D9&7E=$B?)2-!s-GhbvR()8BXv<vS6Bh{K3RV_UMy1A3%Z#_nWgYPVus
z)a=&hmG-t>G?a%B4TcArm&HcG5>ZOlr72HI^Z$y0pBa=}lCa|ezVI+2f|x+e8qfW}
z=z1I<A{Gl(3wpSFqptRaY3alE1eraHA+sSFH)LF9{!d*EfwJq*N+S6tFo)=z5krF!
z<^FLdsMSOgK@epiMhU`l9#qx&AgF<lHyY-T;G;{3@bX0-Pu4po&>59FMxsi`RlzM4
ziyj3;MFv3@fk=XGKhr2^i*bM{{rdxm{@%G=-+sgcmANLOo*7|iaNP6cGV#jAVks&Q
zC?NP<03|X&5pwrR`ZX(BVTZ5AH&o#h7sqnh0v>Roubz7+1+V0XH7;Nt88oz7BmCHF
zE9#p@X!?BLq0)YSBrB}8z{~@~W74CT=AnC-PX_7{Kouz@m<kD+85yL`*b+w`h)lTq
zb}%nmj2Vv-w3uq9i_pvjxST`0!2ZuRfr;PB%zi;}qjFrFTJ%^nVfN~vQxD8i7u^T~
z-)m;s|1xtAY;v3jsHDXiNhs(7>n@X-5?FFdz|RQ#PMI3Ca(|MoX?#ST5-1l{_eh+@
zg4s3NrUc&GA)x#EY2pkf83Dp`b(=8}zs|8jK5*s%mBCi;+tILEdjjuj9V&l=cy9Su
zlm2f=Zu^qyNhT03s^5lJeR|2YC%jbeMSS5mTQ0QQ%!EAfme32+J$!-Fhy@$Uc?CU{
zQl4{Hj3i#-P;Gd^O5PckzshS{jwC+w_7iaw(Pmf|L+}(hinwdEWBU*zcJ}Iz00RKF
W4Hgz4ZFm^~0000<MNUMnLSTY^-<YWY

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/moveToAnotherChangelist@2x_dark.png b/platform/icons/src/actions/moveToAnotherChangelist@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..a218d0570cd3bacc8d7e0e76d10e0a624756cfb6
GIT binary patch
literal 893
zcmV-@1A_dCP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#A4x<(RCwCNS50UWQ4pTDKgp(B6B~;a
zQLs@l6`?1wrMBWPDk=*0t_TW(1rPOPZ+a?tu(ygALGYx9f|a7x`b)J6DYZsJu>@+Y
zru4@q*kt!T=Or6xW7f@XQakYR_V2y<X5PG+S;80tJJQ+NnY*+%F;Cjt+X){9SYeUM
zum-XDJu54LU@%zpx8ZR3uV>}lf@_9#W+*7-BybgR-R`7v2cc~e%W(?25b>2FP=n}4
zR3m=cI)+EOo@B<5+V<}mYqG=TsWbU+R73f8#4zFjqRrTrqVhl{QtJ~pi!!xeF~;%i
zyo;NX=M3c`#6iOY9gAXP*%DDs*5)bCNyq<+fgc5wTavKj0lx4kB8r$q%o@*q0)cfn
z-a{mps}>A!_r_d3^V8D1V4BRH#*kT`jT<r{Gv9~0xWD>S_4#PI3Ctn-X2j5NRJn7M
z30eb@L=Z$7h*5&DoCh@RR{%8s`?`4dA$)WJ5m~&*gLsQ$0(~*5Hyl%XuLy3bQuHVw
zDl!PN2t*Px_A{M=o=gEuWxn5w7<x0e<Lmd7zrNH&G%zEK3{Q9-ULvYoDORC!zXF2K
z1+Yp6s6g(jl(}XVOYHDAdPi!#VsgBcE#Ltc`r^5DTu>z+tabtO$e^RuI^oA&UsB(6
zLi6W)_g4+^BUx*;1!f)?9hdGWbPwIhyfRRa0Gdc4%``~U!YClk#+EqpKy=bQSjSYf
z7&9IvXff4I7omj-aA`$6#s1GWfyv*>%pO5;qjFrFTJ%^nZT4!PQxD8i7u^5?-)m;s
z|1xtAY;>FlsHCSDNh|0A>n@X-5?F9bz{d#tMwu3{a(|YsX?(<-5~vY1cR0lof#Mo%
zQvz@85XkuYQTh}n837`5&6_b1zbLUn-gV{yjlov+)mTJpI)-;m4wb(|JhuF+$^SPb
zH@w;OBol~Kv~0txK^_w}mGe@)3-OuXY&qLwGZXT_TR<;N5AX#}BIa!<=N0rsPI<{)
zF_L(OLxbT7D|u~L{=BShIg<E@LnGoa;<jO30>M+@7^2%~$9D5yKs$T&M}PqU9zqpu
TGiOF-00000NkvXXu0mjf-I0{j

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/moveToAnotherChangelist_dark.png b/platform/icons/src/actions/moveToAnotherChangelist_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..cff9a29738d92872a54a65a1657e20ed9c2cfac7
GIT binary patch
literal 494
zcmV<K0TKR*P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzkV!;ARCwBA{Qv(y13KvL?q<-?&|tW6
z;|8WA5-2S#Wn^I>0DuNDViSiMPS5}-Kz9k;P_O}>llP)Za~LsbFnmMTFb{|m(M@I|
z(gpTF><h$;&?Q)KIFVu611_*jZoK&SKS1Kg8=z1K5FZ5MI6^LX3B;#?c(eH5cMPTi
zzn>#%M)5zkK)m~x@yF@Ae7*1fuzhg9$;iyG@6Vra``*Y11LZici==(W<pr?Ke;L1@
zzA9X&z|6xM!ORKt0y7f><M&_6k3Wj7<!1W9aQo&phQI%ra0cR|D}0^r{_rtc{NZC}
z_{GJ@@Qd?5!!Ne~46^L6mI$$aV(=3_(ikXmh!N@yMsydv_`>zpotcw^fsy$)Fj#^3
zF9XBBzrT?!j0NHbU<$<Qh0niPf64v<MaW-7IQ{?g2iX7_d||-*`~UaH4F7&BqeSZ8
zzsTyJVl`kg&jg5-?~Otj-ZS{)Nl=UNxc~&V0dXM^TVc_B42U}kC1p?sZ~@{bP?`YZ
kUr@RUD*g@K0Du4k0E4oF(FLgezyJUM07*qoM6N<$f=Y<wBme*a

literal 0
HcmV?d00001


From 47c7983713af6c084598465e092db9d8fd6c88a0 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 16:55:43 +0100
Subject: [PATCH 293/354] lambda: check more specific method based on lambda
 return types with wildcards

---
 .../src/com/intellij/psi/LambdaUtil.java      |  4 +--
 .../AmbiguityReturnValueResolution2.java      | 27 +++++++++++++++++++
 .../lambda/methodRef/ReturnTypeSpecific.java  |  4 +--
 .../daemon/lambda/LambdaHighlightingTest.java |  4 +++
 4 files changed, 35 insertions(+), 4 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java

diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
index 672f290abbdc..43428e871930 100644
--- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
@@ -689,9 +689,9 @@ public class LambdaUtil {
       return 1;
     }
 
-    final PsiClassType.ClassResolveResult r = PsiUtil.resolveGenericsClassInType(returnType);
+    final PsiClassType.ClassResolveResult r = PsiUtil.resolveGenericsClassInType(GenericsUtil.eliminateWildcards(returnType));
     final PsiClass rClass = r.getElement();
-    final PsiClassType.ClassResolveResult r1 = PsiUtil.resolveGenericsClassInType(returnType1);
+    final PsiClassType.ClassResolveResult r1 = PsiUtil.resolveGenericsClassInType(GenericsUtil.eliminateWildcards(returnType1));
     final PsiClass rClass1 = r1.getElement();
     if (rClass != null && rClass1 != null) {
       if (rClass == rClass1) {
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java
new file mode 100644
index 000000000000..c89c855e10c9
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java
@@ -0,0 +1,27 @@
+public class Test<A, B extends Number>  {
+    interface IO<T> {
+        T _(Object o);
+    }
+
+    interface IN<T extends Number> {
+        T _(Object o);
+    }
+
+
+    private void foo(IO<? extends A> <warning descr="Parameter 'p' is never used">p</warning>) {}
+    private void <warning descr="Private method 'foo(Test.IN<? extends B>)' is never used">foo</warning>(IN<? extends B> <warning descr="Parameter 'p' is never used">p</warning>) {}
+
+
+    private static class Inner<A extends Object, B extends Number> {
+        private void <warning descr="Private method 'm8(Test.IO<? extends A>)' is never used">m8</warning>(IO<? extends A> <warning descr="Parameter 'p' is never used">p</warning>) {}
+        private void m8(IN<? extends B> <warning descr="Parameter 'p' is never used">p</warning>) {}
+    }
+
+    public static void main(String[] args) {
+        Inner<Number, Double> inn = new Inner<>();
+        inn.m8(p -> 1.0);
+        new Test<Number, Integer>().foo(p -> 1.0);
+
+    }
+}
+
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java
index d714ffdc254e..2a617de711f8 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java
@@ -58,11 +58,11 @@ class MyTest1 {
         System.out.println(i);
     }
 
-    private static void m(I2 i) {
+    private static void <warning descr="Private method 'm(MyTest1.I2)' is never used">m</warning>(I2 i) {
         System.out.println(i);
     }
 
-    private static void <warning descr="Private method 'm(MyTest1.I3)' is never used">m</warning>(I3 i) {
+    private static void m(I3 i) {
         System.out.println(i);
     }
 
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 695bcdb92adf..3da62914842b 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -212,6 +212,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest();
   }
 
+  public void testAmbiguityReturnValueResolution2() throws Exception {
+    doTest(true);
+  }
+
   public void testLambdaOnVarargsPlace1() throws Exception {
     doTest();
   }

From a55b0fa17b8f5753bcdbdb5be4e0c9a284193693 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 18:00:45 +0100
Subject: [PATCH 294/354] lambda/method refs: more specific according to
 15.12.2.5 - prefer private when private type is given/reference when
 reference type is given

---
 .../src/com/intellij/psi/LambdaUtil.java      | 56 ++++++++++++++++---
 .../AmbiguityReturnValueResolution3.java      | 29 ++++++++++
 .../daemon/lambda/LambdaHighlightingTest.java |  4 ++
 3 files changed, 80 insertions(+), 9 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java

diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
index 43428e871930..973f77b0e71c 100644
--- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java
@@ -652,7 +652,7 @@ public class LambdaUtil {
             final PsiType interfaceReturnType1 = getReturnType(functionalInterfaceIdx, conflict);
             if (actualParameterTypes[functionalInterfaceIdx] instanceof PsiLambdaExpressionType || actualParameterTypes[functionalInterfaceIdx] instanceof PsiMethodReferenceType) {
               if (interfaceReturnType != null && interfaceReturnType1 != null && !Comparing.equal(interfaceReturnType, interfaceReturnType1)) {
-                int moreSpecific1 = isMoreSpecific(interfaceReturnType, interfaceReturnType1);
+                int moreSpecific1 = isMoreSpecific(interfaceReturnType, interfaceReturnType1, actualParameterTypes[functionalInterfaceIdx]);
                 if (moreSpecific < 0 && moreSpecific1 > 0 || moreSpecific > 0 && moreSpecific1 < 0) {
                   moreSpecific = 0;
                   break;
@@ -676,17 +676,33 @@ public class LambdaUtil {
     }
   }
 
-  private static int isMoreSpecific(PsiType returnType, PsiType returnType1) {
+  enum TypeKind {
+    PRIMITIVE, REFERENCE, NONE_DETERMINED
+  }
+  
+  private static int isMoreSpecific(PsiType returnType, PsiType returnType1, PsiType lambdaType) {
     if (returnType == PsiType.VOID || returnType1 == PsiType.VOID) return 0;
-    if (returnType instanceof PsiPrimitiveType) {
-      if (!(returnType1 instanceof PsiPrimitiveType)) {
-        return -1;
-      } else {
-        return TypeConversionUtil.isAssignable(returnType, returnType1) ? 1 : -1;
+    TypeKind typeKind = TypeKind.PRIMITIVE;
+    if (lambdaType instanceof PsiLambdaExpressionType) {
+      typeKind = areLambdaReturnExpressionsPrimitive((PsiLambdaExpressionType)lambdaType);
+    } else if (lambdaType instanceof PsiMethodReferenceType) {
+      final PsiElement referencedElement = ((PsiMethodReferenceType)lambdaType).getExpression().resolve();
+      if (referencedElement instanceof PsiMethod && !(((PsiMethod)referencedElement).getReturnType() instanceof PsiPrimitiveType)) {
+        typeKind = TypeKind.REFERENCE;
       }
     }
-    if (returnType1 instanceof PsiPrimitiveType) {
-      return 1;
+    if (typeKind != TypeKind.NONE_DETERMINED) {
+      if (returnType instanceof PsiPrimitiveType) {
+        final int moreSpecific = typeKind == TypeKind.PRIMITIVE ? 1 : -1;
+        if (!(returnType1 instanceof PsiPrimitiveType)) {
+          return -moreSpecific;
+        } else {
+          return TypeConversionUtil.isAssignable(returnType, returnType1) ? moreSpecific : -moreSpecific;
+        }
+      }
+      if (returnType1 instanceof PsiPrimitiveType) {
+        return typeKind == TypeKind.PRIMITIVE ? 1 : -1;
+      }
     }
 
     final PsiClassType.ClassResolveResult r = PsiUtil.resolveGenericsClassInType(GenericsUtil.eliminateWildcards(returnType));
@@ -728,6 +744,28 @@ public class LambdaUtil {
     return 0;
   }
 
+  private static TypeKind areLambdaReturnExpressionsPrimitive(PsiLambdaExpressionType lambdaType) {
+    final List<PsiExpression> returnExpressions = getReturnExpressions(lambdaType.getExpression());
+    TypeKind typeKind = TypeKind.NONE_DETERMINED;
+    for (PsiExpression expression : returnExpressions) {
+      final PsiType returnExprType = expression.getType();
+      if (returnExprType instanceof PsiPrimitiveType) {
+        if (typeKind == TypeKind.REFERENCE) {
+          typeKind = TypeKind.NONE_DETERMINED;
+          break;
+        }
+        typeKind = TypeKind.PRIMITIVE;
+      } else {
+        if (typeKind == TypeKind.PRIMITIVE) {
+          typeKind = TypeKind.NONE_DETERMINED;
+          break;
+        }
+        typeKind = TypeKind.REFERENCE;
+      }
+    }
+    return typeKind;
+  }
+
   @Nullable
   private static PsiType getReturnType(int functionalTypeIdx, CandidateInfo method) {
     final PsiParameter[] methodParameters = ((PsiMethod)method.getElement()).getParameterList().getParameters();
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java
new file mode 100644
index 000000000000..435e10da0634
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java
@@ -0,0 +1,29 @@
+class Test {
+    static class Inner {
+        int foo() { return 0; }
+        Integer fooBoxed() { return 0; }
+    }
+    
+    void test(Stream<Inner> sp) {
+        IntStream mi = sp.map(Inner::foo);
+        Stream<Integer> mI = sp.map(Inner::fooBoxed);
+
+        IntStream li = sp.map(inner->inner.foo());
+        Stream<Integer> lI = sp.map(inner -> inner.fooBoxed());
+    }
+
+    interface Stream<T> {
+        <R> Stream<R> map(Function<? super T, ? extends R> mapper);
+        IntStream map(IntFunction<? super T> mapper);
+    }
+
+    interface Function<T, R> {
+        public R _(T t);
+    }
+
+    interface IntFunction<T> {
+        public int _(T t);
+    }
+
+    interface IntStream {}
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 3da62914842b..4bfd140270bc 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -216,6 +216,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     doTest(true);
   }
 
+  public void testAmbiguityReturnValueResolution3() throws Exception {
+    doTest();
+  }
+
   public void testLambdaOnVarargsPlace1() throws Exception {
     doTest();
   }

From 632b3759b6d0926a4a535cdeb21608bdc47e6e48 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 18:44:55 +0100
Subject: [PATCH 295/354] replace ConsoleMessages icons

---
 platform/icons/src/actions/consoleHistory.png   | Bin 768 -> 0 bytes
 .../src/{vcs => general}/messageHistory.png     | Bin
 .../src/{vcs => general}/messageHistory@2x.png  | Bin
 .../{vcs => general}/messageHistory@2x_dark.png | Bin
 .../{vcs => general}/messageHistory_dark.png    | Bin
 .../src/idea/PlatformActions.xml                |   4 ++--
 .../platform-resources/src/idea/VcsActions.xml  |   2 +-
 .../util/src/com/intellij/icons/AllIcons.java   |  16 ++++++++--------
 .../com/intellij/openapi/util/IconLoader.java   |   4 +++-
 9 files changed, 14 insertions(+), 12 deletions(-)
 delete mode 100644 platform/icons/src/actions/consoleHistory.png
 rename platform/icons/src/{vcs => general}/messageHistory.png (100%)
 rename platform/icons/src/{vcs => general}/messageHistory@2x.png (100%)
 rename platform/icons/src/{vcs => general}/messageHistory@2x_dark.png (100%)
 rename platform/icons/src/{vcs => general}/messageHistory_dark.png (100%)

diff --git a/platform/icons/src/actions/consoleHistory.png b/platform/icons/src/actions/consoleHistory.png
deleted file mode 100644
index 9ac71e7ec590607127630e6d9388a47dc79b107f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmV+b1ONPqP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!qDe$SRCwBKQ(Z_DQ561W=FaAlnX9W=
zE@4n$VL?Ta;`$I_mKFI}h!T;3hEyO?Z}t{whDd=LSUnd(nk0loCZv*x<wF>_vFl6j
zZmzqnJ2Q7~XJ*yiwJtOF%+EdN`#JYYLI~V_`0_jcH-u0iNjyC+EcnFJj$4N`!}LVs
z+HbbLw!O7(-$vfrWJL*?v8(U(qHc=*<>;Ris|kISr2__|+>YE7Fo_vm6zQD{I1~v5
zISegVF6>%fiCyyfej+!|J<ZZlIb}R}H1Lm-(!Czk*PW#Qz;YypuXA&7s16~^N@t3J
zg+_2~t&J3u&lb8YNhr>9*sKT{Q&W>RyX+#*SU4OS&tPCBcJ@5WK)-gm2Byn{xTa(D
z!zi?b23LMTG|Rd5TsRa$s(?spzuDZ7)J>C<$tZHE(1`o^_$LIHe!=N<BG=`<y%_LE
z6onzfL@TlT$#eUen4_ifJoKDG%+LS8x7ismRmFk*2N4Ja`WREe7|&#2QWI`8HP{*z
z8Svz9K_nW($h#pV606v@Jr^8~2x*5(#Z;?E$^&5=_qhLs{a#&l1Uo7YV|aKFp-|9H
zsPcNzJunh1Ey;!<Oc-QZMi&f1Zn|1;o4J#;`~7~*Oiw~4tw)cQqoiaHqOrJ{NHAKX
z(w!!OQ_^m?W22Zt8)xv%D;S1>it;L)Jzb4eT_n9SG+U;*&Vc+fuixqNr5jr9Epvr}
zOF3t1FT$DaUTMD96V?rDD@oMK1Wbh!s0ztCOq<8h+o8dUiO;p6NW87Eop&tV&jPbt
zrPe5nk-^N4Y;zl};q&>5KaP#ncq=RM#rwX)`li4jj*{J4K^uz8bU3*JPDSL+1$z5?
yn<!Z+JASG;)ne1W&9y_uxdBbrp=lca3NQdLo>k-Bcx8bA0000<MNUMnLSTZ@8fI7k

diff --git a/platform/icons/src/vcs/messageHistory.png b/platform/icons/src/general/messageHistory.png
similarity index 100%
rename from platform/icons/src/vcs/messageHistory.png
rename to platform/icons/src/general/messageHistory.png
diff --git a/platform/icons/src/vcs/messageHistory@2x.png b/platform/icons/src/general/messageHistory@2x.png
similarity index 100%
rename from platform/icons/src/vcs/messageHistory@2x.png
rename to platform/icons/src/general/messageHistory@2x.png
diff --git a/platform/icons/src/vcs/messageHistory@2x_dark.png b/platform/icons/src/general/messageHistory@2x_dark.png
similarity index 100%
rename from platform/icons/src/vcs/messageHistory@2x_dark.png
rename to platform/icons/src/general/messageHistory@2x_dark.png
diff --git a/platform/icons/src/vcs/messageHistory_dark.png b/platform/icons/src/general/messageHistory_dark.png
similarity index 100%
rename from platform/icons/src/vcs/messageHistory_dark.png
rename to platform/icons/src/general/messageHistory_dark.png
diff --git a/platform/platform-resources/src/idea/PlatformActions.xml b/platform/platform-resources/src/idea/PlatformActions.xml
index bb17b322ad78..fef7604fb3d2 100644
--- a/platform/platform-resources/src/idea/PlatformActions.xml
+++ b/platform/platform-resources/src/idea/PlatformActions.xml
@@ -538,8 +538,8 @@
     <group id="Console.HistoryActions">
       <action id="Console.History.Previous" class="com.intellij.openapi.actionSystem.EmptyAction"/>
       <action id="Console.History.Next" class="com.intellij.openapi.actionSystem.EmptyAction"/>
-      <action id="Console.History.Browse" class="com.intellij.openapi.actionSystem.EmptyAction" icon="AllIcons.Actions.ConsoleHistory"/>
-      <action id="Console.History.BrowseTW" class="com.intellij.openapi.actionSystem.EmptyAction" use-shortcut-of="RecentFiles" icon="AllIcons.Actions.ConsoleHistory"/>
+      <action id="Console.History.Browse" class="com.intellij.openapi.actionSystem.EmptyAction" icon="AllIcons.General.MessageHistory"/>
+      <action id="Console.History.BrowseTW" class="com.intellij.openapi.actionSystem.EmptyAction" use-shortcut-of="RecentFiles" icon="AllIcons.General.MessageHistory"/>
     </group>
 
     <group id="Internal" text="Internal Actions" internal="true" popup="true">
diff --git a/platform/platform-resources/src/idea/VcsActions.xml b/platform/platform-resources/src/idea/VcsActions.xml
index 42350582c136..6c49368972b7 100644
--- a/platform/platform-resources/src/idea/VcsActions.xml
+++ b/platform/platform-resources/src/idea/VcsActions.xml
@@ -211,7 +211,7 @@
               icon="AllIcons.Vcs.CheckSpelling"/>
       <action id="Vcs.ShowMessageHistory"
               class="com.intellij.openapi.vcs.actions.ShowMessageHistoryAction"
-              icon="AllIcons.Vcs.MessageHistory"/>
+              icon="AllIcons.General.MessageHistory"/>
     </group>
 
     <group id="VcsToobarActions">
diff --git a/platform/util/src/com/intellij/icons/AllIcons.java b/platform/util/src/com/intellij/icons/AllIcons.java
index e8d6ae046a33..84cd93886b38 100644
--- a/platform/util/src/com/intellij/icons/AllIcons.java
+++ b/platform/util/src/com/intellij/icons/AllIcons.java
@@ -47,7 +47,6 @@ public class AllIcons {
     public static final Icon Collapseall = IconLoader.getIcon("/actions/collapseall.png"); // 16x16
     public static final Icon Commit = IconLoader.getIcon("/actions/commit.png"); // 16x16
     public static final Icon Compile = IconLoader.getIcon("/actions/compile.png"); // 16x16
-    public static final Icon ConsoleHistory = IconLoader.getIcon("/actions/consoleHistory.png"); // 16x16
     public static final Icon Copy = IconLoader.getIcon("/actions/copy.png"); // 16x16
     public static final Icon CreateFromUsage = IconLoader.getIcon("/actions/createFromUsage.png"); // 16x16
     public static final Icon CreatePatch = IconLoader.getIcon("/actions/createPatch.png"); // 16x16
@@ -77,6 +76,7 @@ public class AllIcons {
     public static final Icon GroupByModule = IconLoader.getIcon("/actions/GroupByModule.png"); // 16x16
     public static final Icon GroupByModuleGroup = IconLoader.getIcon("/actions/GroupByModuleGroup.png"); // 16x16
     public static final Icon GroupByPackage = IconLoader.getIcon("/actions/GroupByPackage.png"); // 16x16
+    public static final Icon GroupByPrefix = IconLoader.getIcon("/actions/GroupByPrefix.png"); // 16x16
     public static final Icon GroupByTestProduction = IconLoader.getIcon("/actions/groupByTestProduction.png"); // 16x16
     public static final Icon Help = IconLoader.getIcon("/actions/help.png"); // 16x16
     public static final Icon Install = IconLoader.getIcon("/actions/install.png"); // 16x16
@@ -236,7 +236,7 @@ public class AllIcons {
     public static final Icon Db_muted_invalid_method_breakpoint = IconLoader.getIcon("/debugger/db_muted_invalid_method_breakpoint.png"); // 12x12
     public static final Icon Db_muted_method_breakpoint = IconLoader.getIcon("/debugger/db_muted_method_breakpoint.png"); // 12x12
     public static final Icon Db_muted_method_warning_breakpoint = IconLoader.getIcon("/debugger/db_muted_method_warning_breakpoint.png"); // 16x16
-    public static final Icon Db_muted_temporary_breakpoint = IconLoader.getIcon("/debugger/db_muted_temporary_breakpoint.png"); // 16x16
+    public static final Icon Db_muted_temporary_breakpoint = IconLoader.getIcon("/debugger/db_muted_temporary_breakpoint.png"); // 12x12
     public static final Icon Db_muted_verified_breakpoint = IconLoader.getIcon("/debugger/db_muted_verified_breakpoint.png"); // 12x12
     public static final Icon Db_muted_verified_field_breakpoint = IconLoader.getIcon("/debugger/db_muted_verified_field_breakpoint.png"); // 12x12
     public static final Icon Db_muted_verified_method_breakpoint = IconLoader.getIcon("/debugger/db_muted_verified_method_breakpoint.png"); // 12x12
@@ -244,7 +244,7 @@ public class AllIcons {
     public static final Icon Db_obsolete = IconLoader.getIcon("/debugger/db_obsolete.png"); // 12x12
     public static final Icon Db_primitive = IconLoader.getIcon("/debugger/db_primitive.png"); // 16x16
     public static final Icon Db_set_breakpoint = IconLoader.getIcon("/debugger/db_set_breakpoint.png"); // 12x12
-    public static final Icon Db_temporary_breakpoint = IconLoader.getIcon("/debugger/db_temporary_breakpoint.png"); // 16x16
+    public static final Icon Db_temporary_breakpoint = IconLoader.getIcon("/debugger/db_temporary_breakpoint.png"); // 12x12
     public static final Icon Db_verified_breakpoint = IconLoader.getIcon("/debugger/db_verified_breakpoint.png"); // 12x12
     public static final Icon Db_verified_field_breakpoint = IconLoader.getIcon("/debugger/db_verified_field_breakpoint.png"); // 12x12
     public static final Icon Db_verified_method_breakpoint = IconLoader.getIcon("/debugger/db_verified_method_breakpoint.png"); // 12x12
@@ -431,6 +431,7 @@ public class AllIcons {
     public static final Icon Mdot_empty = IconLoader.getIcon("/general/mdot-empty.png"); // 8x8
     public static final Icon Mdot_white = IconLoader.getIcon("/general/mdot-white.png"); // 8x8
     public static final Icon Mdot = IconLoader.getIcon("/general/mdot.png"); // 8x8
+    public static final Icon MessageHistory = IconLoader.getIcon("/general/messageHistory.png"); // 16x16
     public static final Icon Modified = IconLoader.getIcon("/general/modified.png"); // 24x16
     public static final Icon MoreTabs = IconLoader.getIcon("/general/moreTabs.png"); // 16x16
     public static final Icon Mouse = IconLoader.getIcon("/general/mouse.png"); // 32x32
@@ -1075,16 +1076,15 @@ public class AllIcons {
   
   public static class Vcs {
     public static final Icon AllRevisions = IconLoader.getIcon("/vcs/allRevisions.png"); // 16x16
-    public static final Icon Arrow_left = IconLoader.getIcon("/vcs/arrow_left.png"); // 12x12
-    public static final Icon Arrow_right = IconLoader.getIcon("/vcs/arrow_right.png"); // 12x12
+    public static final Icon Arrow_left = IconLoader.getIcon("/vcs/arrow_left.png"); // 16x16
+    public static final Icon Arrow_right = IconLoader.getIcon("/vcs/arrow_right.png"); // 16x16
     public static final Icon CheckSpelling = IconLoader.getIcon("/vcs/checkSpelling.png"); // 16x16
-    public static final Icon Equal = IconLoader.getIcon("/vcs/equal.png"); // 12x12
+    public static final Icon Equal = IconLoader.getIcon("/vcs/equal.png"); // 16x16
     public static final Icon History = IconLoader.getIcon("/vcs/history.png"); // 16x16
     public static final Icon MapBase = IconLoader.getIcon("/vcs/mapBase.png"); // 16x16
     public static final Icon Merge = IconLoader.getIcon("/vcs/merge.png"); // 12x12
     public static final Icon MergeSourcesTree = IconLoader.getIcon("/vcs/mergeSourcesTree.png"); // 16x16
-    public static final Icon MessageHistory = IconLoader.getIcon("/vcs/messageHistory.png"); // 16x16
-    public static final Icon Not_equal = IconLoader.getIcon("/vcs/not_equal.png"); // 12x12
+    public static final Icon Not_equal = IconLoader.getIcon("/vcs/not_equal.png"); // 16x16
     public static final Icon Remove = IconLoader.getIcon("/vcs/remove.png"); // 16x16
     public static final Icon ResetStrip = IconLoader.getIcon("/vcs/resetStrip.png"); // 16x16
     public static final Icon StripDown = IconLoader.getIcon("/vcs/stripDown.png"); // 16x16
diff --git a/platform/util/src/com/intellij/openapi/util/IconLoader.java b/platform/util/src/com/intellij/openapi/util/IconLoader.java
index 04872b078ef2..29a0eb1109fb 100644
--- a/platform/util/src/com/intellij/openapi/util/IconLoader.java
+++ b/platform/util/src/com/intellij/openapi/util/IconLoader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -77,6 +77,8 @@ public final class IconLoader {
     ourDeprecatedIconsReplacements.put("/inspector/useFilter.png", "AllIcons.General.Filter");
 
     ourDeprecatedIconsReplacements.put("/actions/showSource.png", "AllIcons.Actions.Preview");
+    ourDeprecatedIconsReplacements.put("/actions/consoleHistory.png", "AllIcons.General.MessageHistory");
+    ourDeprecatedIconsReplacements.put("/vcs/messageHistory.png", "AllIcons.General.MessageHistory");
   }
 
   private static final ImageIcon EMPTY_ICON = new ImageIcon(UIUtil.createImage(1, 1, BufferedImage.TYPE_3BYTE_BGR)) {

From 7f966376b10a6e8a7aeb47055ba0d8b42842961a Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 21:47:05 +0400
Subject: [PATCH 296/354] IDEA-101547 Please add a clock in fullscreen mode!
 After-review: better names for constants

---
 .../openapi/wm/impl/status/ClockPanel.java    | 30 +++++++++----------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
index acc41de7b189..779609263313 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/ClockPanel.java
@@ -38,6 +38,13 @@ import static java.util.Calendar.*;
  */
 public class ClockPanel extends JComponent implements CustomStatusBarWidget {
   @NonNls public static final String WIDGET_ID = "Clock";
+  private static final int TOP = 1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9;
+  private static final int TOP_LEFT = 1 << 0 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9;
+  private static final int TOP_RIGHT = 1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 7 | 1 << 8 | 1 << 9;
+  private static final int MIDDLE = 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9;
+  private static final int BOTTOM_LEFT = 1 << 0 | 1 << 2 | 1 << 6 | 1 << 8;
+  private static final int BOTTOM_RIGHT = 1 << 0 | 1 << 1 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9;
+  private static final int BOTTOM = 1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9;
   //              top
   //              ---
   //    top-left |   | top-right
@@ -47,15 +54,6 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget {
   //             |   |
   //              ---
   //            bottom
-  private static final int[] MASK = new int[]{
-    1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9,//top
-    1 << 0 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9,//top-left
-    1 << 0 | 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 7 | 1 << 8 | 1 << 9,//top-right
-    1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9,//middle
-    1 << 0 | 1 << 2 | 1 << 6 | 1 << 8,//bottom-left
-    1 << 0 | 1 << 1 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7 | 1 << 8 | 1 << 9,//bottom-right
-    1 << 0 | 1 << 2 | 1 << 3 | 1 << 5 | 1 << 6 | 1 << 8 | 1 << 9//bottom
-  };//1005, 881, 927, 892, 325, 1019, 877 (geek mode)
 
   protected final Calendar myCalendar;
   private final Timer myTimer;
@@ -172,12 +170,12 @@ public class ClockPanel extends JComponent implements CustomStatusBarWidget {
     float t54 = t * 5 / 4;
     float t34 = t * 3 / 4;
     float t2 = t / 2;
-    if ((digit & MASK[0]) != 0) g.draw(new Line2D.Float(x + t54, y + t2, x + width - t54, y + t2));
-    if ((digit & MASK[1]) != 0) g.draw(new Line2D.Float(x + t2, y + t54, x + t2, y + h2 - t34));
-    if ((digit & MASK[2]) != 0) g.draw(new Line2D.Float(x + width - t2, y + t54, x + width - t2, y + h2 - t34));
-    if ((digit & MASK[3]) != 0) g.draw(new Line2D.Float(x + t54, y + h2, x + width - t54, y + h2));
-    if ((digit & MASK[4]) != 0) g.draw(new Line2D.Float(x + t2, y + h2 + t34, x + t2, y + height - t54));
-    if ((digit & MASK[5]) != 0) g.draw(new Line2D.Float(x + width - t2, y + h2 + t34, x + width - t2, y + height - t54));
-    if ((digit & MASK[6]) != 0) g.draw(new Line2D.Float(x + t54, y + height - t2, x + width - t54, y + height - t2));
+    if ((digit & TOP) != 0) g.draw(new Line2D.Float(x + t54, y + t2, x + width - t54, y + t2));
+    if ((digit & TOP_LEFT) != 0) g.draw(new Line2D.Float(x + t2, y + t54, x + t2, y + h2 - t34));
+    if ((digit & TOP_RIGHT) != 0) g.draw(new Line2D.Float(x + width - t2, y + t54, x + width - t2, y + h2 - t34));
+    if ((digit & MIDDLE) != 0) g.draw(new Line2D.Float(x + t54, y + h2, x + width - t54, y + h2));
+    if ((digit & BOTTOM_LEFT) != 0) g.draw(new Line2D.Float(x + t2, y + h2 + t34, x + t2, y + height - t54));
+    if ((digit & BOTTOM_RIGHT) != 0) g.draw(new Line2D.Float(x + width - t2, y + h2 + t34, x + width - t2, y + height - t54));
+    if ((digit & BOTTOM) != 0) g.draw(new Line2D.Float(x + t54, y + height - t2, x + width - t54, y + height - t2));
   }
 }

From 419591a5a4e49501035cc1a0406d27953e2ab18b Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 18:52:04 +0100
Subject: [PATCH 297/354] jsf file type

---
 platform/icons/src/actions/addFacesSupport.png  | Bin 544 -> 249 bytes
 .../icons/src/actions/addFacesSupport@2x.png    | Bin 0 -> 620 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/actions/addFacesSupport@2x.png

diff --git a/platform/icons/src/actions/addFacesSupport.png b/platform/icons/src/actions/addFacesSupport.png
index e2ddb5f5539756ec35eded30c99c66ee6fa8ee82..d0b6cd31c9c1ef5201662d770daf6e7559c65b62 100644
GIT binary patch
delta 232
zcmV<E02lwD1o;7w8Gi-<001BJ|6u?C02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM005gwL_t(|+G70w|33pIfCWT!c6O3$3L_H(g@7Uh7+p&sUI2k@J9aUW
zqS?#Ctzv7j8^Qn(@b2A3QdoGqmbA0rk_4F!G?3x;uEh+uc401tSpXJCvXFs=kS!q1
zAcbfyB|Z?*ZH2jxq*%b_bd-dI&2&|_Sgd@kDG`_dh~YD#NiY(N|L^Xp1ksG3%tT3E
iV5BrRQk<Cp0t^67xIgbjnj)|O0000<MNUMnLSTYn0bdmW

delta 530
zcmV+t0`2|z0iXns8Gi!+001a04^sdD0TED4R7L;)|1U#eFGFB2LtrmMU`=C+PHvS+
zTYoN0ghgYQM|P=7Yn)AQpHzCLR%nn{fvR1HuVsd?ZIH5ljjn)?uYj1cgORY2pRzAQ
zU|(>Z+~4Wa*W}aK<a~*qGe>4VQEWd^Y(G(LKT>T%Rc}L8Z-3P3_1Wz7-thD1@$l;L
z@bB>O_WS$z`1pIZ`H#*2kgMjMx9Xz3?4-Z#r@!v1!tlMs&AsFQ&D{3T*yqsS_R;3{
z(&Y9#P;Nhc&p=ae<Lmk4>-*&F`Q-8O<?-+4?)&HO`z>F)=k)*R@cTJ($n5a&?eOsJ
z^Zo7h`%#$U?|<|C@Amxg@bK~Y{Pg<#Sg7px`1tqx`e(TK`1|_#`}_U<{l<KdN&o-=
zBXm+uQvf<UK84lQ+1}pX-rnBc-rnBc-rnBc-sb1^`1t(&{{H^{AXvkK0001+Nkl<Z
zcwUXl)eZtN5J1u5?p7$Uz`Ee>?(XvcA3|wgc-))JB!6=<Kv&j4EE4qlJZ_i6Lcp0{
zHVV(%p}$_(2}HZvS=q>vDAc?J!fj32%F;yOs}w@bJHDqP->FbY96#^ZL%m*3<sU$p
z+toQvWm$G#q957OptYL!X5(RzLMF+i5K1!$#cc#20A`3cje_wHAT;1HVbIwZ`^FR?
UNG_SS01E&B07*qoM6N<$f(ZyYSO5S3

diff --git a/platform/icons/src/actions/addFacesSupport@2x.png b/platform/icons/src/actions/addFacesSupport@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..7d76d3557b0f200aaad4cb94ffdc03b14963412d
GIT binary patch
literal 620
zcmV-y0+aoTP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!4oO5oRCwBA{Qv(y!$1Nih5-gFFh*x*
zC%uD$aZrT7r~^hFz=ADxGP;(~%)<Y>d%(F3W(UgvczPkB5P&<DCYc`*y77ZH4d4Vn
zUOi&CJ*${O+AEzw$jF7^|KC3hFAuC>cz1p;!{47@8JIbE7z7O*8AMDx8Cdy67%sPj
zVweHbOO^xB!K*{789rP+${=dx$H1p)#qj6TTLvaJ4hCjU9=IA&OMjrFoPdtw0`r+U
zxXBLzbnyA!1qLo@6$TzfJqC6`aWKY+a~3uR7A`&%M^UXD;1E|}`1bTR5Z__=_v;7k
z(*Qb<bdF_s`2Hos^W6&=K3+Qtj9XU*UR7fTW_B(_DBV8G@csE+26iDy20=q-1`bhK
z>V*I(Se0TM7!)EZ!L{p?&C|f?;x{lYAk=U(u<?sBu<{8pFae{3q7eB1?=MzyP#OT?
zC!41-e7bp>flEf6fuBzpEXO6I!60JhMV&P8=gWI=DrRJ1#VQZ7`2XMEK!^UJZW{Rc
z<|#POzdpW+fn7v~ft5!PEdKV)PGAb>1t-S8-##(CIkB06Lrji=jZcKS4tTJ#o#EGq
zSKx#sY8A-9C94i~*b|1ASC26K{r&}<@IWCTYVFU!DXmI;(F|)9Bee-(wIN;Fh=aN=
zV5CudpbA<mw&9Ed8haYW9u|7F0|spxU>xy%!%+tS1Q-C1_M8PPcn2W>0000<MNUMn
GLSTY&0s@Bs

literal 0
HcmV?d00001


From a91d63365b5fdce74b19b9d0d82e6cb516c14017 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 18:53:06 +0100
Subject: [PATCH 298/354] reset to empty icon

---
 platform/icons/src/actions/Reset_to_empty.png     | Bin 0 -> 379 bytes
 platform/icons/src/actions/Reset_to_empty@2x.png  | Bin 0 -> 650 bytes
 .../icons/src/actions/Reset_to_empty@2x_dark.png  | Bin 0 -> 652 bytes
 .../icons/src/actions/Reset_to_empty_dark.png     | Bin 0 -> 384 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/actions/Reset_to_empty.png
 create mode 100644 platform/icons/src/actions/Reset_to_empty@2x.png
 create mode 100644 platform/icons/src/actions/Reset_to_empty@2x_dark.png
 create mode 100644 platform/icons/src/actions/Reset_to_empty_dark.png

diff --git a/platform/icons/src/actions/Reset_to_empty.png b/platform/icons/src/actions/Reset_to_empty.png
new file mode 100644
index 0000000000000000000000000000000000000000..825d4e433c4c88add6f55f00d2a767baefb7a4a0
GIT binary patch
literal 379
zcmV->0fhdEP)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz9Z5t%RCwBA{Qv(y10{e3pQPvHz4bt<
z0hj#WUq7mG8W1$|U_B=r3r@{HzkjX%`r(ZmRs-S}9joW%WW}lZ>z6MjpWnXj0Wzm!
z7?8i_Y`p*%J5J3XK7Pu5_5Ar{DEA7A0S()))C+Rs*8J-2`;_|+9?d}#x&}9(Z~x7D
zJ`UW@e)j5J%$1w>mY@k=Wh4}hcC`yZ6ekdWLz8L*Iht|$(L16b*Woea^|I|pLV@%F
zbj{#&@a^XxEdpuf8W3w?(+oD?(~sZ87@&hqGuVLlUw`TlFyIOhhhozVHsHgzpTxLe
z4G>SonioEQ|E*2HfU9T$hyoZX&W$B$X~-sg1>#RY{1zIuAp8=DUm)?{K;=II@n?Vl
Z0|1_PbkKpUnOOh;002ovPDHLkV1g>TrR)Fz

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/Reset_to_empty@2x.png b/platform/icons/src/actions/Reset_to_empty@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..b76c24b3a87ddf215a9a9bf5047f661e42b4e026
GIT binary patch
literal 650
zcmV;50(Jd~P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!EJ;K`RCwCVm%C2GFcgN#4VV~^82Sp7
z2Z1+$2ViDEY?!u~5ebQlgm?fZb|xew5Cak{sE9i#Y8zTYdZCw;q!c@(RR}h9;-C`g
z$my}2@9(jXFG9QB9_Z&I4)pnvNzSQ_1J?c!*<x6Dt7$F}1<0cK=Wxrc1GB78k_AXY
zul~zC@Mfb1>Lnfjfpww)MV5NOL0Gt1tAeWG!0~fQ6fi^=zy+^W-#|$(K#wa;7N8IX
zq<G+Ol?u@F&(P<lL_iTq@TIWua=8MuT+R>IkQqb)!-^ak+$ffSs%9Xe>XNz+49VRH
zBzfSvQ3CgmDx_4WsRD+-<^YB#!ou@<5nSCp!C#vE5&=cxf@?1ZxVV0RJ(`gtuy%Np
z7?h;Y@ND4~oTu*~L(`uEHji!-iX<e%!ZZ0-aC&jW0>|lG#4iGAJKjFI4-DVkKOVsu
z#|U5fwi_Z~3>7(!T@~l_3`4smFT5+jZhee%ZtHkPk2Am_@jUQuf5bTj;0ZMm6y6ok
zv|CX`V46~wpus%?B8fnp0$=WVBs1S_t_Y}Et$>QLpm0aP+};_^fKi?d$Y_O_&zEF@
zI|58AlJSrG;3?))v1!>+j(;GyBcN$TmI0}ta7REyYrr0|txy*eD;fdEVLJ=`z8ebj
zv$K8$__vMMCuDWJQsYA{vIeq>>nnT8np;+V{!aUb+uvN>*{QQ!P6gLQccGHpvhz+d
kk>V3Q-xB`i5PS+S0F+<f53ZY#r~m)}07*qoM6N<$g0pTNlK=n!

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/Reset_to_empty@2x_dark.png b/platform/icons/src/actions/Reset_to_empty@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..f37a675a304897de31f209fe51718b5e0151cf30
GIT binary patch
literal 652
zcmV;70(1R|P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!E=fc|RCwCNm&s1TKp4mAro@8>6G?mp
z@j>(r^x`Xc^5zIQ-c4K*pTHA$PbMZB4<>ps7#Cd9AQdcShhmF3Q!A-;#x7ICBwwa{
zGt=Lnud{vJU@(Y{vhcAH7m?&#*g5h$9wJ){3-9;zRiXfq=l>mU=pCTf)p@c2f%6)_
z!2<7f+n`fZ@gLYG3Xnv>3l74<^>z!iGz*T)HBrDgT>ulj-D-lGT80i+jx0bT3dpd)
zn~ergORv!7rbIyEN$~Zs@Or%glw#2hSCDB$0dYx;46apcK$Z)T&~#1R2gb!=1kx;U
zRjYxACmB+jb5sHGuQ`C>sj%>pS_L=xXZS~#KO!IrOmO8*16Q|?(4!kU0$ay-sWCwa
z4Sy+Dz-2BEeRTaTVE5!cB?(+QEWA*vfb*+6KXAO9tN4K<9mo4;4}swaho_Tx#rcG9
z{x}U0a0XRHhEo-<=_Mci)}8R70JHxw%XqBg89nO*4vF`Hck?63C;(5WxuEc&fS%cp
zA_9w)wiFHS5D-ZOk`(xc=ao!<H<=<JzbIu?O$UWr0#>pYcm+(ctbl@2o^kooe&Ch>
z-H7D-CtdK2?_05Mm{ETJKyXVy&xmXVWP-vi0TJy1S!8>m5)&gD0jHreqveD;6=N-l
z38vJ{eH`N7Cf=Wrb?{D&FSW?J$Qrh<?x@>#-E#TA`*-c}y4~iPoN~7Dwm`wIzn@9Q
mQ+&MRUBq;Y8+CgADZl{w{MxOv`VAfc0000<MNUMnLSTYS4kUU2

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/Reset_to_empty_dark.png b/platform/icons/src/actions/Reset_to_empty_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..d270cf05915dc0495365e97ff957df144fa4732d
GIT binary patch
literal 384
zcmV-`0e}99P)<h;3K|Lk000e1NJLTq000mG000mO1^@s6AM^iV0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzB1uF+RCwBA{Qv(y10{e3pQPvHz4bt<
z0hj#WUq7mG8W1$|U_B=r3r@{HzkjX%`r(ZmRs-S}9joW%WW}lZ>z6MjpWnXj0Wzm!
z7?8i_Y`p*%J5J3XK7Pu5_5Ar{DEA7A0S()))C+Rs*8J-2`;_|+9?d}#x&}9(Z~x7D
zJ`UW@e)j5J%$1w>mY@k=Wh4}hcC`yZ6ekdWLz8L*Iht|$(L16b*Woea^|I|pLV@%F
zbj{#&@a^XxEdpuf8W3w?(+oD?(~sZ87@&hqGuVLlUw`TlFyIOhhhozVHsHgzpTxLe
z4G>SonioEQ|E*2HfU9T$h-yFx?^7{?Sx%D`Z*D|R2w#Et6A-_JMlA@x1mYJ+{5Mef
ek3jqxAiw~SW^y1z!Ji}m0000<MNUMnLSTYVzNVM}

literal 0
HcmV?d00001


From 84bd50994a8d462c94d1db4852865665adbd4482 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 18:16:55 +0100
Subject: [PATCH 299/354] javafx: accept no params handlers (IDEA-102017)

---
 .../plugins/javaFX/fxml/JavaFXHighlightingTest.java          | 5 +++++
 .../javaFX/fxml/refs/JavaFxEventHandlerReference.java        | 1 +
 plugins/javaFX/testData/highlighting/NoParamsHandler.java    | 4 ++++
 plugins/javaFX/testData/highlighting/noParamsHandler.fxml    | 5 +++++
 4 files changed, 15 insertions(+)
 create mode 100644 plugins/javaFX/testData/highlighting/NoParamsHandler.java
 create mode 100644 plugins/javaFX/testData/highlighting/noParamsHandler.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
index f66c68429f01..f6a1a408a01c 100644
--- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
@@ -93,6 +93,11 @@ public class JavaFXHighlightingTest extends DaemonAnalyzerTestCase {
     doDoTest(false, false);
   }
 
+  public void testNoParamsHandler() throws Exception {
+    configureByFiles(null, getTestName(true) + ".fxml", getTestName(false) + ".java");
+    doDoTest(false, false);
+  }
+
   private void doTestIdController() throws Exception {
     final String controllerClassName = getTestName(false) + "Controller";
     configureByFiles(null, getTestName(true) + ".fxml", controllerClassName + ".java");
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java
index ed34c51a9cb5..432e3eeabe25 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/refs/JavaFxEventHandlerReference.java
@@ -79,6 +79,7 @@ public class JavaFxEventHandlerReference extends PsiReferenceBase<XmlAttributeVa
           return true;
         }
       }
+      return parameters.length == 0;
     }
     return false;
   }
diff --git a/plugins/javaFX/testData/highlighting/NoParamsHandler.java b/plugins/javaFX/testData/highlighting/NoParamsHandler.java
new file mode 100644
index 000000000000..c96768e76861
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/NoParamsHandler.java
@@ -0,0 +1,4 @@
+public class Controller {
+  public void sayHelloWorld() {
+  }
+}
\ No newline at end of file
diff --git a/plugins/javaFX/testData/highlighting/noParamsHandler.fxml b/plugins/javaFX/testData/highlighting/noParamsHandler.fxml
new file mode 100644
index 000000000000..a4fc85b8606b
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/noParamsHandler.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.GridPane?>
+<GridPane xmlns:fx="http://javafx.com/fxml" fx:controller="Controller">
+    <Button onAction="#sayHelloWorld"/>
+</GridPane>
\ No newline at end of file

From fc04a028106037b592d2c68c8b4c90b0db1664a9 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 18:23:44 +0100
Subject: [PATCH 300/354] logging for EA-44045 - assert:
 JspTextSyntheticBlock.getSpacing

---
 .../javaFX/fxml/codeInsight/inspections/UnwrapTagFix.java   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/UnwrapTagFix.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/UnwrapTagFix.java
index 1723db0a79fd..2e20e6f720c8 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/UnwrapTagFix.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/codeInsight/inspections/UnwrapTagFix.java
@@ -17,18 +17,22 @@ package org.jetbrains.plugins.javaFX.fxml.codeInsight.inspections;
 
 import com.intellij.codeInspection.LocalQuickFix;
 import com.intellij.codeInspection.ProblemDescriptor;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.psi.xml.XmlTagChild;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.javaFX.fxml.JavaFxFileTypeFactory;
 
 /**
 * User: anna
 */
 public class UnwrapTagFix implements LocalQuickFix {
+  private static final Logger LOG = Logger.getInstance("#" + UnwrapTagFix.class.getName());
   private final String myTagName;
 
   public UnwrapTagFix(String tagName) {
@@ -51,6 +55,8 @@ public class UnwrapTagFix implements LocalQuickFix {
   public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
     final PsiElement element = descriptor.getPsiElement();
     if (element != null) {
+      final PsiFile containingFile = element.getContainingFile();
+      LOG.assertTrue(containingFile != null && JavaFxFileTypeFactory.isFxml(containingFile), containingFile == null ? "no containing file found" : "containing file: " + containingFile.getName());
       final XmlTag xmlTag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
       if (xmlTag != null) {
         final XmlTag parentTag = xmlTag.getParentTag();

From 531ce3d49d5a05eab8c8500c2fa9396d52a9fc94 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 19:29:01 +0100
Subject: [PATCH 301/354] icons

---
 .../codeInspection/ui/SingleInspectionProfilePanel.java       | 4 ++--
 platform/util/src/com/intellij/icons/AllIcons.java            | 1 +
 .../designer/propertyTable/actions/RestoreDefault.java        | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/profile/codeInspection/ui/SingleInspectionProfilePanel.java b/platform/lang-impl/src/com/intellij/profile/codeInspection/ui/SingleInspectionProfilePanel.java
index b9c796e9c4b1..63e1664912b9 100644
--- a/platform/lang-impl/src/com/intellij/profile/codeInspection/ui/SingleInspectionProfilePanel.java
+++ b/platform/lang-impl/src/com/intellij/profile/codeInspection/ui/SingleInspectionProfilePanel.java
@@ -337,7 +337,7 @@ public class SingleInspectionProfilePanel extends JPanel {
     actions.add(actionManager.createCollapseAllAction(myTreeExpander, myTree));
 
     actions.add(new AnAction(CommonBundle.message("button.reset.to.default"), CommonBundle.message("button.reset.to.default"),
-                             AllIcons.Actions.Reset_to_default) {
+                             AllIcons.General.Reset) {
       {
         registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.CTRL_MASK)), myTree);
       }
@@ -353,7 +353,7 @@ public class SingleInspectionProfilePanel extends JPanel {
       }
     });
 
-    actions.add(new AnAction("Reset to Empty", "Reset to empty", AllIcons.General.Reset){
+    actions.add(new AnAction("Reset to Empty", "Reset to empty", AllIcons.Actions.Reset_to_empty){
 
       @Override
       public void update(AnActionEvent e) {
diff --git a/platform/util/src/com/intellij/icons/AllIcons.java b/platform/util/src/com/intellij/icons/AllIcons.java
index 84cd93886b38..322fda10be06 100644
--- a/platform/util/src/com/intellij/icons/AllIcons.java
+++ b/platform/util/src/com/intellij/icons/AllIcons.java
@@ -122,6 +122,7 @@ public class AllIcons {
     public static final Icon Rerun = IconLoader.getIcon("/actions/rerun.png"); // 16x16
     public static final Icon Reset_to_default = IconLoader.getIcon("/actions/reset-to-default.png"); // 16x16
     public static final Icon Reset = IconLoader.getIcon("/actions/reset.png"); // 16x16
+    public static final Icon Reset_to_empty = IconLoader.getIcon("/actions/Reset_to_empty.png"); // 16x16
     public static final Icon Restart = IconLoader.getIcon("/actions/restart.png"); // 16x16
     public static final Icon Resume = IconLoader.getIcon("/actions/resume.png"); // 16x16
     public static final Icon Right = IconLoader.getIcon("/actions/right.png"); // 16x16
diff --git a/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/actions/RestoreDefault.java b/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/actions/RestoreDefault.java
index 54303b0e6b67..fa4527a64e53 100644
--- a/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/actions/RestoreDefault.java
+++ b/plugins/ui-designer-core/src/com/intellij/designer/propertyTable/actions/RestoreDefault.java
@@ -36,7 +36,7 @@ public class RestoreDefault extends AnAction implements IPropertyTableAction {
     String text = DesignerBundle.message("designer.properties.restore_default");
     presentation.setText(text);
     presentation.setDescription(text);
-    presentation.setIcon(AllIcons.Actions.Reset_to_default);
+    presentation.setIcon(AllIcons.General.Reset);
   }
 
   @Override

From f0b0af783f8dd0d4bf6cd486f8cff1a9fb03e2b6 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 19:32:00 +0100
Subject: [PATCH 302/354] icons

---
 .../lang/properties/structureView/GroupByWordPrefixes.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/properties/src/com/intellij/lang/properties/structureView/GroupByWordPrefixes.java b/plugins/properties/src/com/intellij/lang/properties/structureView/GroupByWordPrefixes.java
index 5b351239b641..bd3393591167 100644
--- a/plugins/properties/src/com/intellij/lang/properties/structureView/GroupByWordPrefixes.java
+++ b/plugins/properties/src/com/intellij/lang/properties/structureView/GroupByWordPrefixes.java
@@ -150,7 +150,7 @@ public class GroupByWordPrefixes implements Grouper, Sorter {
   public ActionPresentation getPresentation() {
     return new ActionPresentationData(PropertiesBundle.message("structure.view.group.by.prefixes.action.name"),
                                       PropertiesBundle.message("structure.view.group.by.prefixes.action.description"),
-                                      AllIcons.Actions.FileStatus);
+                                      AllIcons.Actions.GroupByPrefix);
   }
 
   @NotNull

From e304c21ccecd2ba4a402ae892146ee9ded142d18 Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Wed, 27 Feb 2013 22:51:46 +0400
Subject: [PATCH 303/354] Smart menu for full screen mode (MS Windows)

---
 .../intellij/openapi/wm/impl/IdeMenuBar.java  | 185 +++++++++++++++++-
 1 file changed, 184 insertions(+), 1 deletion(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeMenuBar.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeMenuBar.java
index 808b987c79e4..387caa553b5d 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeMenuBar.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/IdeMenuBar.java
@@ -29,11 +29,21 @@ import com.intellij.openapi.actionSystem.impl.WeakTimerListener;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.SystemInfo;
+import com.intellij.openapi.wm.ex.WindowManagerEx;
 import com.intellij.ui.ScreenUtil;
+import com.intellij.util.ui.Animator;
 import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
 import java.awt.*;
+import java.awt.event.AWTEventListener;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.geom.AffineTransform;
 import java.util.ArrayList;
 
 /**
@@ -43,6 +53,17 @@ import java.util.ArrayList;
  * @author Vladimir Kondratyev
  */
 public class IdeMenuBar extends JMenuBar {
+
+  private static final int COLLAPSED_HEIGHT = 2;
+
+  private enum State {
+    EXPANDED, COLLAPSING, COLLAPSED, EXPANDING, TEMPORARY_EXPANDED;
+
+    boolean isInProgress() {
+      return this == COLLAPSING || this == EXPANDING;
+    }
+  }
+
   private final MyTimerListener myTimerListener;
   private ArrayList<AnAction> myVisibleActions;
   private ArrayList<AnAction> myNewVisibleActions;
@@ -52,6 +73,13 @@ public class IdeMenuBar extends JMenuBar {
   private final Disposable myDisposable = Disposer.newDisposable();
   private boolean DISABLED = false;
 
+  @Nullable private final Animator myAnimator;
+  @Nullable private final Timer myActivationWatcher;
+  @NotNull private State myState = State.EXPANDED;
+  private double myProgress = 0;
+  private boolean myMouseInside = false;
+  private boolean myActivated = false;
+
   public IdeMenuBar(ActionManagerEx actionManager, DataManager dataManager) {
     myActionManager = actionManager;
     myTimerListener = new MyTimerListener();
@@ -59,6 +87,121 @@ public class IdeMenuBar extends JMenuBar {
     myNewVisibleActions = new ArrayList<AnAction>();
     myPresentationFactory = new MenuItemPresentationFactory();
     myDataManager = dataManager;
+    if (SystemInfo.isWindows) {
+      myAnimator = new Animator("MenuBarAnimator", 8, 300, false) {
+        @Override
+        public void paintNow(int frame, int totalFrames, int cycle) {
+          myProgress = (1 - Math.cos(Math.PI * ((float)frame / totalFrames))) / 2;
+          revalidate();
+          repaint();
+        }
+
+        @Override
+        protected void paintCycleEnd() {
+          myProgress = 1;
+          switch (myState) {
+            case COLLAPSING:
+              setState(State.COLLAPSED);
+              break;
+            case EXPANDING:
+              setState(State.TEMPORARY_EXPANDED);
+              break;
+            default:
+          }
+          revalidate();
+          repaint();
+        }
+      };
+      Toolkit.getDefaultToolkit().addAWTEventListener(new AWTEventListener() {
+        @Override
+        public void eventDispatched(AWTEvent event) {
+          MouseEvent mouseEvent = (MouseEvent)event;
+          Component component = mouseEvent.getComponent();
+          Component deepestComponent = SwingUtilities.getDeepestComponentAt(mouseEvent.getComponent(), mouseEvent.getX(), mouseEvent.getY());
+          if (deepestComponent != null) {
+            component = deepestComponent;
+          }
+
+          if (myState != State.EXPANDED && !myState.isInProgress()) {
+            myMouseInside = myActivated || isDescendingFrom(component, IdeMenuBar.this);
+            if (myMouseInside && myState == State.COLLAPSED) {
+              setState(State.EXPANDING);
+              restartAnimator();
+            }
+            else if (!myMouseInside && myState != State.COLLAPSING && myState != State.COLLAPSED) {
+              setState(State.COLLAPSING);
+              restartAnimator();
+            }
+          }
+        }
+      }, AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK);
+      myActivationWatcher = new Timer(100, new ActionListener() {
+        @Override
+        public void actionPerformed(ActionEvent e) {
+          if (myState == State.EXPANDED || myState == State.EXPANDING)
+            return;
+          boolean activated = isActivated();
+          if (myActivated && !activated && myState == State.TEMPORARY_EXPANDED) {
+            myActivated = false;
+            setState(State.COLLAPSING);
+            restartAnimator();
+          }
+          if (activated)
+            myActivated = true;
+        }
+      });
+    }
+    else {
+      myAnimator = null;
+      myActivationWatcher = null;
+    }
+  }
+
+  private static boolean isDescendingFrom(@Nullable Component a, @NotNull Component b) {
+    while (a != null) {
+      if (a == b) {
+        return true;
+      }
+
+      if (a instanceof JPopupMenu) {
+        a = ((JPopupMenu)a).getInvoker();
+      } else {
+        a = a.getParent();
+      }
+    }
+    return false;
+  }
+
+  private boolean isActivated() {
+    int index = getSelectionModel().getSelectedIndex();
+    if (index ==-1)
+      return false;
+    return getMenu(index).isPopupMenuVisible();
+  }
+
+
+  private void setState(@NotNull State state) {
+    myState = state;
+  }
+
+  @Override
+  public Dimension getPreferredSize() {
+    Dimension dimension = super.getPreferredSize();
+    if (myState.isInProgress()) {
+      dimension.height =
+        COLLAPSED_HEIGHT + (int)((myState == State.COLLAPSING ? (1 - myProgress) : myProgress) * (dimension.height - COLLAPSED_HEIGHT));
+    }
+    else if (myState == State.COLLAPSED) {
+      dimension.height = COLLAPSED_HEIGHT;
+    }
+    return dimension;
+  }
+
+  private void restartAnimator() {
+    if (myAnimator != null) {
+      myAnimator.reset();
+      myAnimator.resume();
+    }
   }
 
   /**
@@ -68,8 +211,24 @@ public class IdeMenuBar extends JMenuBar {
   public void addNotify() {
     super.addNotify();
     updateMenuActions();
-    if (!ScreenUtil.isStandardAddRemoveNotify(this))
+    if (!ScreenUtil.isStandardAddRemoveNotify(this)) {
+      Window window = SwingUtilities.getWindowAncestor(this);
+      if (window instanceof IdeFrameImpl) {
+        boolean fullScreen = WindowManagerEx.getInstanceEx().isFullScreen((IdeFrameImpl)window);
+        if (fullScreen) {
+          setState(State.COLLAPSING);
+          restartAnimator();
+        } else {
+          if (myAnimator != null) {
+            myAnimator.suspend();
+          }
+          setState(State.EXPANDED);
+          revalidate();
+          repaint();
+        }
+      }
       return;
+    }
     // Add updater for menus
     myActionManager.addTimerListener(1000, new WeakTimerListener(myActionManager, myTimerListener));
     UISettingsListener UISettingsListener = new UISettingsListener() {
@@ -80,6 +239,9 @@ public class IdeMenuBar extends JMenuBar {
     };
     UISettings.getInstance().addUISettingsListener(UISettingsListener, myDisposable);
     Disposer.register(ApplicationManager.getApplication(), myDisposable);
+    if (myActivationWatcher != null) {
+      myActivationWatcher.start();
+    }
   }
 
   /**
@@ -88,6 +250,12 @@ public class IdeMenuBar extends JMenuBar {
   @Override
   public void removeNotify() {
     if (ScreenUtil.isStandardAddRemoveNotify(this)) {
+      if (myActivationWatcher != null) {
+        myActivationWatcher.stop();
+      }
+      if (myAnimator != null) {
+        myAnimator.suspend();
+      }
       Disposer.dispose(myDisposable);
     }
     super.removeNotify();
@@ -144,6 +312,21 @@ public class IdeMenuBar extends JMenuBar {
     }
   }
 
+  @Override
+  protected void paintChildren(Graphics g) {
+    if (SystemInfo.isWindows && myState.isInProgress()) {
+      Graphics2D g2 = (Graphics2D)g;
+      AffineTransform oldTransform = g2.getTransform();
+      AffineTransform newTransform = oldTransform != null ? new AffineTransform(oldTransform) : new AffineTransform();
+      newTransform.concatenate(AffineTransform.getTranslateInstance(0, getHeight() - super.getPreferredSize().height));
+      g2.setTransform(newTransform);
+      super.paintChildren(g2);
+      g2.setTransform(oldTransform);
+    } else {
+      super.paintChildren(g);
+    }
+  }
+
   /**
    * Hacks a problem under Alloy LaF which draws menu bar in different background menu items are drawn in.
    */

From 9a35df2a7bc9baf437f8117cf13a11e93930459a Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 12:42:29 +0100
Subject: [PATCH 304/354] Typos

---
 .../psi/parser-partial/annotations/Complex.txt     |  6 +++---
 .../psi/parser-partial/annotations/Nested.txt      |  6 +++---
 .../psi/parser-partial/annotations/Simple0.txt     |  6 +++---
 .../java/parser/partial/AnnotationParserTest.java  | 14 ++++++--------
 4 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/java/java-tests/testData/psi/parser-partial/annotations/Complex.txt b/java/java-tests/testData/psi/parser-partial/annotations/Complex.txt
index 5211c0a10ec1..c9f20092db3b 100644
--- a/java/java-tests/testData/psi/parser-partial/annotations/Complex.txt
+++ b/java/java-tests/testData/psi/parser-partial/annotations/Complex.txt
@@ -17,6 +17,6 @@ PsiJavaFile:Complex.java
       PsiNameValuePair
         PsiIdentifier:second('second')
         PsiJavaToken:EQ('=')
-        PsiLiteralExpression:"Wampirchik"
-          PsiJavaToken:STRING_LITERAL('"Wampirchik"')
-      PsiJavaToken:RPARENTH(')')
+        PsiLiteralExpression:"Another Eugene"
+          PsiJavaToken:STRING_LITERAL('"Another Eugene"')
+      PsiJavaToken:RPARENTH(')')
\ No newline at end of file
diff --git a/java/java-tests/testData/psi/parser-partial/annotations/Nested.txt b/java/java-tests/testData/psi/parser-partial/annotations/Nested.txt
index e8cfe4480a70..61c9f1cdf6f5 100644
--- a/java/java-tests/testData/psi/parser-partial/annotations/Nested.txt
+++ b/java/java-tests/testData/psi/parser-partial/annotations/Nested.txt
@@ -26,7 +26,7 @@ PsiJavaFile:Nested.java
             PsiNameValuePair
               PsiIdentifier:second('second')
               PsiJavaToken:EQ('=')
-              PsiLiteralExpression:"Wampirchik"
-                PsiJavaToken:STRING_LITERAL('"Wampirchik"')
+              PsiLiteralExpression:"Yet One Eugene"
+                PsiJavaToken:STRING_LITERAL('"Yet One Eugene"')
             PsiJavaToken:RPARENTH(')')
-      PsiJavaToken:RPARENTH(')')
+      PsiJavaToken:RPARENTH(')')
\ No newline at end of file
diff --git a/java/java-tests/testData/psi/parser-partial/annotations/Simple0.txt b/java/java-tests/testData/psi/parser-partial/annotations/Simple0.txt
index 486549bf98a5..64d10e9a1f4e 100644
--- a/java/java-tests/testData/psi/parser-partial/annotations/Simple0.txt
+++ b/java/java-tests/testData/psi/parser-partial/annotations/Simple0.txt
@@ -8,6 +8,6 @@ PsiJavaFile:Simple0.java
     PsiAnnotationParameterList
       PsiJavaToken:LPARENTH('(')
       PsiNameValuePair
-        PsiLiteralExpression:"bla-bla-bla"
-          PsiJavaToken:STRING_LITERAL('"bla-bla-bla"')
-      PsiJavaToken:RPARENTH(')')
+        PsiLiteralExpression:"blah-blah-blah"
+          PsiJavaToken:STRING_LITERAL('"blah-blah-blah"')
+      PsiJavaToken:RPARENTH(')')
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/AnnotationParserTest.java b/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/AnnotationParserTest.java
index c6db3569f299..c51da086ce46 100644
--- a/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/AnnotationParserTest.java
+++ b/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/AnnotationParserTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -19,30 +19,28 @@ import com.intellij.lang.PsiBuilder;
 import com.intellij.lang.java.parser.JavaParser;
 import com.intellij.lang.java.parser.JavaParsingTestCase;
 
-
 public class AnnotationParserTest extends JavaParsingTestCase {
   public AnnotationParserTest() {
     super("parser-partial/annotations");
   }
 
   public void testMarker() { doParserTest("@Preliminary"); }
-  public void testSimple0() { doParserTest("@Copyright(\"bla-bla-bla\")"); }
+  public void testSimple0() { doParserTest("@Copyright(\"blah-blah-blah\")"); }
   public void testSimple1() { doParserTest("@Copyright(treatedAsValue)"); }
-  public void testComplex() { doParserTest("@Author(first=\"Eugene\", second=\"Wampirchik\")"); }
+  public void testComplex() { doParserTest("@Author(first=\"Eugene\", second=\"Another Eugene\")"); }
   public void testMultiple() { doParserTest("@Preliminary @Other(name=value)"); }
   public void testArray() { doParserTest("@Endorsers({\"Children\", \"Unscrupulous dentists\"})"); }
-  public void testNested() { doParserTest("@Author(@Name(first=\"Eugene\", second=\"Wampirchik\"))"); }
+  public void testNested() { doParserTest("@Author(@Name(first=\"Eugene\", second=\"Yet One Eugene\"))"); }
   public void testQualifiedAnnotation() { doParserTest("@org.jetbrains.annotations.Nullable"); }
   public void testExtraCommaInList() { doParserTest("@Anno({0, 1,})"); }
-
   public void testParameterizedAnnotation () { doParserTest("@Nullable<T>"); }
   public void testFirstNameMissed() { doParserTest("@Anno(value1, param2=value2)"); }
 
   private void doParserTest(final String text) {
-    doParserTest(text, new MyTestParser1());
+    doParserTest(text, new MyTestParser());
   }
 
-  private static class MyTestParser1 implements TestParser {
+  private static class MyTestParser implements TestParser {
     @Override
     public void parse(final PsiBuilder builder) {
       JavaParser.INSTANCE.getDeclarationParser().parseAnnotations(builder);

From eaf18465f802dbdbdc8e4492d8ff2f0df8990145 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 20:20:52 +0100
Subject: [PATCH 305/354] Test cleanup

---
 .../daemon/lambda/LambdaHighlightingTest.java | 275 ++++--------------
 1 file changed, 57 insertions(+), 218 deletions(-)

diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
index 4bfd140270bc..0e576f80047d 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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,227 +32,66 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase {
     };
   }
 
-  public void testStaticAccess() throws Exception {
-    doTest();
-  }
+  public void testStaticAccess() { doTest(); }
+  public void testEffectiveFinal() { doTest(); }
+  public void testReassignUsedVars() { doTest(); }
+  public void testLambdaContext() { doTest(); }
+  public void testReturnTypeCompatibility() { doTest(); }
+  public void testTypeArgsConsistency() { doTest(); }
+  public void testTypeArgsConsistencyMisc1() { doTest(); }
+  public void testTypeArgsConsistencyMisc2() { doTest(); }
+  public void testTypeArgsConsistencyWithoutParams() { doTest(); }
+  public void testIncompatibleReturnTypes() { doTest(); }
+  public void testWildcardBounds() { doTest(); }
+  public void testInferenceOnMethodCallSite() { doTest(); }
+  public void testInferFromTypeArgs() { doTest(); }
+  public void testAmbiguity1() { doTest(); }
+  //public void testAmbiguity2() { doTest(); }
+  public void testAmbiguityVarargs() { doTest(); }
+  public void testAmbiguityRawGenerics() { doTest(); }
+  public void testDefaultMethod() { doTest(); }
+  public void testLambdaOnVarargsPlace() { doTest(); }
+  public void testLambdaRawOrNot() { doTest(); }
+  public void testReturnTypeCompatibility1() { doTest(); }
+  public void testNoInferenceResult() { doTest(); }
+  public void testInferenceFromArgs() { doTest(); }
+  public void testInContexts() { doTest(); }
+  public void testCastInContexts() { doTest(); }
+  public void testUnhandledException() { doTest(); }
+  public void testConditionalExpr() { doTest(); }
+  public void testIncompleteSubst() { doTest(); }
+  public void testVariableInitialization() { doTest(); }
+  public void testUnreachableStatement() { doTest(); }
+  public void testUnhandledExceptions() { doTest(); }
+  public void testReturnValue() { doTest(); }
+  public void testAlreadyUsedParamName() { doTest(); }
+  public void testRecursiveAccess() { doTest(); }
+  public void testIncompatibleFormalParameterTypes() { doTest(); }
+  public void testNestedLambdas() { doTest(); }
+  public void testEnumConstants() { doTest(); }
+  public void testRawWhenNoParams() { doTest(); }
+  public void testUseIncompleteParentSubstitutor() { doTest(); }
+  public void testReturnTypeCompatibilityBeforeSpecificsCheck() { doTest(); }
+  public void testIntersectionTypeInCast() { doTest(); }
+  public void testAmbiguitySpecificReturn() { doTest(true); }
+  public void testFunctionalInterfaceAnnotation() { doTest(); }
+  public void testAmbiguityReturnValueResolution() { doTest(); }
+  public void testAmbiguityReturnValueResolution1() { doTest(); }
+  public void testAmbiguityReturnValueResolution2() { doTest(true); }
+  public void testAmbiguityReturnValueResolution3() { doTest(); }
+  public void testLambdaOnVarargsPlace1() { doTest(); }
+  public void testInferenceFromSecondLambda() { doTest(); }
+  public void testAcceptRawSubstForLambda() { doTest(); }
+  public void testCheckFunctionalInterfaceAccess() { doTest(); }
+  public void testVoidCompatibility() { doTest(); }
+  public void testConditionalInferenceFromOppositePart() { doTest(); }
+  public void testDeclaredTypeParameterBoundsAndUnboundedWildcard() { doTest(); }
 
-  public void testEffectiveFinal() throws Exception {
-    doTest();
-  }
-
-  public void testReassignUsedVars() throws Exception {
-    doTest();
-  }
-
-  public void testLambdaContext() throws Exception {
-    doTest();
-  }
-
-  public void testReturnTypeCompatibility() throws Exception {
-    doTest();
-  }
-
-  public void testTypeArgsConsistency() throws Exception {
-    doTest();
-  }
-
-  public void testTypeArgsConsistencyMisc1() throws Exception {
-    doTest();
-  }
-
-  public void testTypeArgsConsistencyMisc2() throws Exception {
-    doTest();
-  }
-
-  public void testTypeArgsConsistencyWithoutParams() throws Exception {
-    doTest();
-  }
-
-  public void testIncompatibleReturnTypes() throws Exception {
-    doTest();
-  }
-
-  public void testWildcardBounds() throws Exception {
-    doTest();
-  }
-
-  public void testInferenceOnMethodCallSite() throws Exception {
-    doTest();
-  }
-
-  public void testInferFromTypeArgs() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguity1() throws Exception {
-    doTest();
-  }
-
-  public void _testAmbiguity2() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguityVarargs() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguityRawGenerics() throws Exception {
-    doTest();
-  }
-
-  public void testDefaultMethod() throws Exception {
-    doTest();
-  }
-
-  public void testLambdaOnVarargsPlace() throws Exception {
-    doTest();
-  }
-
-  public void testLambdaRawOrNot() throws Exception {
-    doTest();
-  }
-
-  public void testReturnTypeCompatibility1() throws Exception {
-    doTest();
-  }
-
-  public void testNoInferenceResult() throws Exception {
-    doTest();
-  }
-
-  public void testInferenceFromArgs() throws Exception {
-    doTest();
-  }
-
-  public void testInContexts() throws Exception {
-    doTest();
-  }
-
-  public void testCastInContexts() throws Exception {
-    doTest();
-  }
-
-  public void testUnhandledException() throws Exception {
-    doTest();
-  }
-
-  public void testConditionalExpr() throws Exception {
-    doTest();
-  }
-
-  public void testIncompleteSubst() throws Exception {
-    doTest();
-  }
-
-  public void testVariableInitialization() throws Exception {
-    doTest();
-  }
-
-  public void testUnreachableStatement() throws Exception {
-    doTest();
-  }
-
-  public void testUnhandledExceptions() throws Exception {
-    doTest();
-  }
-
-  public void testReturnValue() throws Exception {
-    doTest();
-  }
-
-  public void testAlreadyUsedParamName() throws Exception {
-    doTest();
-  }
-
-  public void testRecursiveAccess() throws Exception {
-    doTest();
-  }
-
-  public void testIncompatibleFormalParameterTypes() throws Exception {
-    doTest();
-  }
-
-  public void testNestedLambdas() throws Exception {
-    doTest();
-  }
-
-  public void testEnumConstants() throws Exception {
-    doTest();
-  }
-
-  public void testRawWhenNoParams() throws Exception {
-    doTest();
-  }
-
-  public void testUseIncompleteParentSubstitutor() throws Exception {
-    doTest();
-  }
-
-  public void testReturnTypeCompatibilityBeforeSpecificsCheck() throws Exception {
-    doTest();
-  }
-
-  public void testIntersectionTypeInCast() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguitySpecificReturn() throws Exception {
-    doTest(true);
-  }
-
-  public void testFunctionalInterfaceAnnotation() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguityReturnValueResolution() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguityReturnValueResolution1() throws Exception {
-    doTest();
-  }
-
-  public void testAmbiguityReturnValueResolution2() throws Exception {
-    doTest(true);
-  }
-
-  public void testAmbiguityReturnValueResolution3() throws Exception {
-    doTest();
-  }
-
-  public void testLambdaOnVarargsPlace1() throws Exception {
-    doTest();
-  }
-
-  public void testInferenceFromSecondLambda() throws Exception {
-    doTest();
-  }
-
-  public void testAcceptRawSubstForLambda() throws Exception {
-    doTest();
-  }
-
-  public void testCheckFunctionalInterfaceAccess() throws Exception {
-    doTest();
-  }
-
-  public void testVoidCompatibility() throws Exception {
-    doTest();
-  }
-
-  public void testConditionalInferenceFromOppositePart() throws Exception {
-    doTest();
-  }
-
-  public void testDeclaredTypeParameterBoundsAndUnboundedWildcard() throws Exception {
-    doTest();
-  }
-
-  private void doTest() throws Exception {
+  private void doTest() {
     doTest(false);
   }
 
-  private void doTest(final boolean checkWarnings) throws Exception {
+  private void doTest(final boolean checkWarnings) {
     doTest(BASE_PATH + "/" + getTestName(false) + ".java", checkWarnings, false);
   }
 }

From d84ce3b88ca6d911a31f624f97d9c50fe0dba5de Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 20:23:34 +0100
Subject: [PATCH 306/354] Test cleanup

---
 .../lambda/MethodRefHighlightingTest.java     | 221 ++++--------------
 1 file changed, 46 insertions(+), 175 deletions(-)

diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
index 93c0f64da8f2..c43f639cc326 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/MethodRefHighlightingTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -34,185 +34,56 @@ public class MethodRefHighlightingTest extends LightDaemonAnalyzerTestCase {
       new UnusedSymbolLocalInspection(),
     };
   }
-  
-  public void testValidContext() throws Exception {
-    doTest();
-  }
 
-  public void testAssignability() throws Exception {
-    doTest();
-  }
-  
-  public void testAmbiguity() throws Exception {
-    doTest();
-  }
+  public void testValidContext() { doTest(); }
+  public void testAssignability() { doTest(); }
+  public void testAmbiguity() { doTest(); }
+  public void testMethodReferenceReceiver() { doTest(); }
+  public void testMethodRefMisc() { doTest(); }
+  public void testMethodTypeParamsInference() { doTest(); }
+  public void testMethodRefMisc1() { doTest(); }
+  public void testQualifierTypeArgs() { doTest(); }
+  public void testStaticProblems() { doTest(); }
+  public void testConstructorRefs() { doTest(); }
+  public void testConstructorRefsInnerClasses() { doTest(); }
+  public void testVarargs() { doTest(); }
+  public void testVarargs1() { doTest(); }
+  public void testConstructorRefInnerFromSuper() { doTest(); }
+  public void testReferenceParameters() { doTest(); }
+  public void testRawQualifier() { doTest(); }
+  public void testCyclicInference() { doTest(); }
+  public void testAccessModifiers() { doTest(); }
+  public void testDefaultConstructor() { doTest(); }
+  public void testWildcards() { doTest(); }
+  public void testVarargsInReceiverPosition() { doTest(); }
+  public void testInferenceFromMethodReference() { doTest(); }
+  public void testAssignability1() { doTest(); }
+  public void testTypeArgumentsOnMethodRefs() { doTest(); }
+  public void testConstructorAssignability() { doTest(); }
+  public void testConstructorWithoutParams() { doTest(); }
+  public void testSOE() { doTest(); }
+  public void testInferenceFromReturnType() { doTest(true); }
+  public void testReturnTypeSpecific() { doTest(true); }
+  public void testResolveConflicts() { doTest(true); }
+  public void testIntersectionTypeInCast() { doTest(false); }
+  public void testUnhandledExceptions() { doTest(); }
+  public void testCapturedWildcards() { doTest(); }
+  public void testConstructorNonAbstractAbstractExpected() { doTest(); }
+  public void test100441() { doTest(); }
+  public void testSuperClassSubst() { doTest(); }
+  public void testNonParameterizedReceiver() { doTest(); }
+  public void testFunctionalInterfaceMethodIsGeneric() { doTest(); /*accepted for method ref, though forbidden for lambda*/ }
+  public void testStaticMethodOnTypedClassReference() { doTest(); }
+  public void testRefOnArrayDeclaration() { doTest(); }
+  public void testGetClassSpecifics() { doTest(); }
+  public void testAbstractMethod() { doTest(); }
+  public void testMethodRefAcceptance() { doTest(); }
 
-  public void testMethodReferenceReceiver() throws Exception {
-    doTest();
-  }
-  
-  public void testMethodRefMisc() throws Exception {
-    doTest();
-  }
-
-  public void testMethodTypeParamsInference() throws Exception {
-    doTest();
-  }
-
-  public void testMethodRefMisc1() throws Exception {
-    doTest();
-  }
-
-  public void testQualifierTypeArgs() throws Exception {
-    doTest();
-  }
-
-  public void testStaticProblems() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorRefs() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorRefsInnerClasses() throws Exception {
-    doTest();
-  }
-  
-  public void testVarargs() throws Exception {
-    doTest();
-  }
-
-  public void testVarargs1() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorRefInnerFromSuper() throws Exception {
-    doTest();
-  }
-
-  public void testReferenceParameters() throws Exception {
-    doTest();
-  }
-
-  public void testRawQualifier() throws Exception {
-    doTest();
-  }
-
-  public void testCyclicInference() throws Exception {
-    doTest();
-  }
-
-  public void testAccessModifiers() throws Exception {
-    doTest();
-  }
-  
-  public void testDefaultConstructor() throws Exception {
-    doTest();
-  }
-
-  public void testWildcards() throws Exception {
-    doTest();
-  }
-
-  public void testVarargsInReceiverPosition() throws Exception {
-    doTest();
-  }
-
-  public void testInferenceFromMethodReference() throws Exception {
-    doTest();
-  }
-
-  public void testAssignability1() throws Exception {
-    doTest();
-  }
-
-  public void testTypeArgumentsOnMethodRefs() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorAssignability() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorWithoutParams() throws Exception {
-    doTest();
-  }
-
-  public void testSOE() throws Exception {
-    doTest();
-  }
-
-  public void testInferenceFromReturnType() throws Exception {
-    doTest(true);
-  }
-
-  public void testReturnTypeSpecific() throws Exception {
-    doTest(true);
-  }
-
-  public void testResolveConflicts() throws Exception {
-    doTest(true);
-  }
-
-  public void testIntersectionTypeInCast() throws Exception {
+  private void doTest() {
     doTest(false);
   }
 
-  public void testUnhandledExceptions() throws Exception {
-    doTest();
-  }
-
-  public void testCapturedWildcards() throws Exception {
-    doTest();
-  }
-
-  public void testConstructorNonAbstractAbstractExpected() throws Exception {
-    doTest();
-  }
-
-  public void test100441() throws Exception {
-    doTest();
-  }
-
-  public void testSuperClassSubst() throws Exception {
-    doTest();
-  }
-
-  public void testNonParameterizedReceiver() throws Exception {
-    doTest();
-  }
-
-  public void testFunctionalInterfaceMethodIsGeneric() throws Exception {
-    //accepted for method ref, though forbidden for lambda
-    doTest();
-  }
-
-  public void testStaticMethodOnTypedClassReference() throws Exception {
-    doTest();
-  }
-
-  public void testRefOnArrayDeclaration() throws Exception {
-    doTest();
-  }
-
-  public void testGetClassSpecifics() throws Exception {
-    doTest();
-  }
-
-  public void testAbstractMethod() throws Exception {
-    doTest();
-  }
-
-  public void testMethodRefAcceptance() throws Exception {
-    doTest();
-  }
-
-  private void doTest() throws Exception {
-    doTest(false);
-  }
-
-  private void doTest(final boolean warnings) throws Exception {
+  private void doTest(boolean warnings) {
     ((JavaVersionServiceImpl)JavaVersionService.getInstance()).setTestVersion(JavaSdkVersion.JDK_1_8, getTestRootDisposable());
     doTest(BASE_PATH + "/" + getTestName(false) + ".java", warnings, false);
   }

From ac17ef8b7526950efa51c68ebe4852b1ce406fd8 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 20:11:29 +0100
Subject: [PATCH 307/354] javafx: controller navigation with <fx:root>
 available (IDEA-102036)

---
 .../javaFX/fxml/JavaFXHighlightingTest.java   |  4 ++
 .../plugins/javaFX/fxml/JavaFxPsiUtil.java    | 40 ++++++++++++++-----
 .../highlighting/injected/FooVBox.java        | 23 +++++++++++
 .../highlighting/injected/MyController.java   |  5 +++
 .../injected/injectedController.fxml          |  5 +++
 5 files changed, 66 insertions(+), 11 deletions(-)
 create mode 100644 plugins/javaFX/testData/highlighting/injected/FooVBox.java
 create mode 100644 plugins/javaFX/testData/highlighting/injected/MyController.java
 create mode 100644 plugins/javaFX/testData/highlighting/injected/injectedController.fxml

diff --git a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
index f6a1a408a01c..ece46c7016d3 100644
--- a/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
+++ b/plugins/javaFX/javaFX-CE/testSrc/org/jetbrains/plugins/javaFX/fxml/JavaFXHighlightingTest.java
@@ -127,6 +127,10 @@ public class JavaFXHighlightingTest extends DaemonAnalyzerTestCase {
     doDoTest(false, false);
   }
 
+  public void testInjectedController() throws Exception {
+    doTestNavigation("MyController", "label",  "injected/" + getTestName(true) + ".fxml", "injected/FooVBox.java", "injected/MyController.java");
+  }
+
   private void doTestNavigation(String resultClassName, String resultFieldName) throws Exception {
     doTestNavigation(resultClassName, resultFieldName, ArrayUtil.EMPTY_STRING_ARRAY);
   }
diff --git a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
index c381600a8a7b..1339035f833e 100644
--- a/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
+++ b/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java
@@ -18,6 +18,7 @@ package org.jetbrains.plugins.javaFX.fxml;
 import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.lang.ASTNode;
 import com.intellij.lang.xml.XMLLanguage;
+import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
@@ -211,19 +212,34 @@ public class JavaFxPsiUtil {
       final Project project = containingFile.getProject();
       if (rootTag != null) {
         XmlAttribute attribute = rootTag.getAttribute(FxmlConstants.FX_CONTROLLER);
-        if (attribute == null && FxmlConstants.FX_ROOT.equals(rootTag.getName())) {
-          attribute = rootTag.getAttribute(FxmlConstants.TYPE);
-        }
         if (attribute != null) {
-          final String attributeValue = attribute.getValue();
-          if (!StringUtil.isEmptyOrSpaces(attributeValue)) {
-            return  JavaPsiFacade.getInstance(project).findClass(attributeValue, containingFile.getResolveScope());
+          final PsiClass controllerClass = findControllerClass(containingFile, project, attribute);
+          if (controllerClass != null) {
+            return controllerClass;
           }
         }
       }
-      CachedValuesManager manager = CachedValuesManager.getManager(containingFile.getProject());
-      return manager.getCachedValue(containingFile, INJECTED_CONTROLLER,
-                                    new JavaFxControllerCachedValueProvider(containingFile.getProject(), containingFile), true);
+      final CachedValuesManager manager = CachedValuesManager.getManager(containingFile.getProject());
+      final PsiClass injectedControllerClass = manager.getCachedValue(containingFile, INJECTED_CONTROLLER, 
+                                                                      new JavaFxControllerCachedValueProvider(containingFile.getProject(), containingFile), true);
+      if (injectedControllerClass != null) {
+        return injectedControllerClass;
+      }
+
+      if (rootTag != null && FxmlConstants.FX_ROOT.equals(rootTag.getName())) {
+        final XmlAttribute rootTypeAttr = rootTag.getAttribute(FxmlConstants.TYPE);
+        if (rootTypeAttr != null) {
+          return findControllerClass(containingFile, project, rootTypeAttr);
+        }
+      }
+    }
+    return null;
+  }
+
+  private static PsiClass findControllerClass(PsiFile containingFile, Project project, XmlAttribute attribute) {
+    final String attributeValue = attribute.getValue();
+    if (!StringUtil.isEmptyOrSpaces(attributeValue)) {
+      return  JavaPsiFacade.getInstance(project).findClass(attributeValue, containingFile.getResolveScope());
     }
     return null;
   }
@@ -426,7 +442,9 @@ public class JavaFxPsiUtil {
               return methodCallExpression.resolveMethod() == injectControllerMethods[0];
             }
           };
-          ReferencesSearch.search(myContainingFile).forEach(new Processor<PsiReference>() {
+          final GlobalSearchScope globalSearchScope = GlobalSearchScope
+                      .notScope(GlobalSearchScope.getScopeRestrictedByFileTypes(myContainingFile.getResolveScope(), StdFileTypes.XML));
+          ReferencesSearch.search(myContainingFile, globalSearchScope).forEach(new Processor<PsiReference>() {
             @Override
             public boolean process(PsiReference reference) {
               final PsiElement element = reference.getElement();
@@ -436,7 +454,7 @@ public class JavaFxPsiUtil {
                   final PsiType type = expression.getType();
                   if (type != null && type.equalsToText(JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER)) {
                     final PsiElement parent = expression.getParent();
-                    if (parent instanceof PsiVariable) {
+                    if (parent instanceof PsiLocalVariable) {
                       ReferencesSearch.search(parent).forEach(processor);
                       final PsiClass controller = processor.getInjectedController();
                       if (controller != null) {
diff --git a/plugins/javaFX/testData/highlighting/injected/FooVBox.java b/plugins/javaFX/testData/highlighting/injected/FooVBox.java
new file mode 100644
index 000000000000..57eafa26d5cf
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/injected/FooVBox.java
@@ -0,0 +1,23 @@
+import javafx.fxml.FXMLLoader;
+import javafx.scene.layout.VBox;
+
+import java.io.IOException;
+
+
+public class FooVBox extends VBox{
+    private void loaderCreation() {
+        MyController controller =  new MyController();
+        FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("injectedController.fxml"));
+        fxmlLoader.setRoot(this);
+        fxmlLoader.setController(controller);
+
+        try {
+            fxmlLoader.load();
+        } catch (IOException exception) {
+            throw new RuntimeException(exception);
+        }
+    }
+    public FooVBox() {
+        loaderCreation();
+    }
+}
diff --git a/plugins/javaFX/testData/highlighting/injected/MyController.java b/plugins/javaFX/testData/highlighting/injected/MyController.java
new file mode 100644
index 000000000000..b96c485324b1
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/injected/MyController.java
@@ -0,0 +1,5 @@
+import javafx.scene.control.Label;
+
+public class MyController {
+    public Label label;
+}
diff --git a/plugins/javaFX/testData/highlighting/injected/injectedController.fxml b/plugins/javaFX/testData/highlighting/injected/injectedController.fxml
new file mode 100644
index 000000000000..524575935010
--- /dev/null
+++ b/plugins/javaFX/testData/highlighting/injected/injectedController.fxml
@@ -0,0 +1,5 @@
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Button?>
+<fx:root type="javafx.scene.layout.VBox" xmlns:fx="http://javafx.com/fxml">
+    <Label fx:id="la<caret>bel" />
+</fx:root>
\ No newline at end of file

From d86690f5376f47eb0d369c93c2de9f23074fe820 Mon Sep 17 00:00:00 2001
From: anna <Anna.Kozlova@jetbrains.com>
Date: Wed, 27 Feb 2013 20:23:39 +0100
Subject: [PATCH 308/354] unsupported syntax in .form fixed $ was a valid class
 name delimiter

---
 .../ant/config/impl/configuration/AntClasspathEditorPanel.form  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/ant/src/com/intellij/lang/ant/config/impl/configuration/AntClasspathEditorPanel.form b/plugins/ant/src/com/intellij/lang/ant/config/impl/configuration/AntClasspathEditorPanel.form
index 0acb741d97e5..21b11258cb75 100644
--- a/plugins/ant/src/com/intellij/lang/ant/config/impl/configuration/AntClasspathEditorPanel.form
+++ b/plugins/ant/src/com/intellij/lang/ant/config/impl/configuration/AntClasspathEditorPanel.form
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="com.intellij.lang.ant.config.impl.configuration.AntClasspathEditorPanel$Form">
+<form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="com.intellij.lang.ant.config.impl.configuration.AntClasspathEditorPanel.Form">
   <grid id="e8f1e" binding="myWholePanel" layout-manager="GridLayoutManager" row-count="6" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>

From f4330beba2269b3c47b5026d35433bbb243712ae Mon Sep 17 00:00:00 2001
From: Kirill Safonov <kirill.safonov@jetbrains.com>
Date: Wed, 27 Feb 2013 23:29:36 +0400
Subject: [PATCH 309/354] WEB-6865 JS icons of perl files

---
 platform/platform-resources/src/FileTypeManager.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/platform-resources/src/FileTypeManager.xml b/platform/platform-resources/src/FileTypeManager.xml
index 23b433ca62e2..a381b19a9a5f 100644
--- a/platform/platform-resources/src/FileTypeManager.xml
+++ b/platform/platform-resources/src/FileTypeManager.xml
@@ -63,7 +63,7 @@
       </highlighting>
     </filetype>
 
-    <filetype binary="false" default_extension="cs" extensions="cs" description="C# files" name="C#" icon="AllIcons.FileTypes.JavaScript">
+    <filetype binary="false" default_extension="cs" extensions="cs" description="C# files" name="C#" icon="AllIcons.FileTypes.Custom">
       <highlighting>
         <options>
           <option name="LINE_COMMENT" value="//" />
@@ -80,7 +80,7 @@
       </highlighting>
     </filetype>
     
-    <filetype binary="false" default_extension="pl" extensions="pl;pm" description="Perl files" name="Perl" icon="AllIcons.FileTypes.JavaScript">
+    <filetype binary="false" default_extension="pl" extensions="pl;pm" description="Perl files" name="Perl" icon="AllIcons.FileTypes.Custom">
       <highlighting>
         <options>
           <option name="LINE_COMMENT" value="#" />

From 54a7b4dc70ef56be7992db6e073a92b62318dbb9 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 20:40:44 +0100
Subject: [PATCH 310/354] Deprecated extension method syntax dropped

---
 .../DeprecatedDefenderSyntaxInspection.java   | 67 -------------------
 .../lang/java/parser/DeclarationParser.java   | 28 ++++----
 .../intellij/psi/impl/cache/RecordUtil.java   | 12 ++--
 .../java/stubs/JavaMethodElementType.java     | 23 +++----
 .../java/stubs/impl/PsiMethodStubImpl.java    | 12 +---
 .../psi/impl/source/PsiModifierListImpl.java  | 28 +-------
 .../advHighlighting/UnsupportedFeatures.java  |  2 +-
 .../lambda/highlighting/DefaultMethod.java    |  5 +-
 .../ExtensionMethodSyntax.java                |  8 ---
 .../interfaceMethods/ExtensionMethods.java    | 16 ++---
 .../lambda/methodRef/Wildcards.java           |  4 +-
 .../anonymous2lambda/afterQualifiedThis.java  |  2 +-
 .../anonymous2lambda/beforeQualifiedThis.java |  2 +-
 .../afterDoNotImplementExtensionMethods.java  |  2 +-
 .../afterImplementExtensionMethods.java       |  2 +-
 .../beforeDoNotImplementExtensionMethods.java |  2 +-
 .../beforeImplementExtensionMethods.java      |  2 +-
 .../parser-partial/declarations/Extension.txt |  9 ++-
 .../parser-partial/declarations/Unclosed8.txt |  9 ++-
 .../parser-partial/declarations/Unclosed9.txt | 25 -------
 .../refactoring/pullUp/ExtensionMethod.java   |  2 +-
 .../pullUp/ExtensionMethod_after.java         |  2 +-
 .../pushDown/ExtensionMethodToClass.java      |  2 +-
 .../pushDown/ExtensionMethodToInterface.java  |  2 +-
 .../ExtensionMethodToInterface_after.java     |  2 +-
 .../Interface8MethodsHighlightingTest.java    |  6 --
 .../parser/partial/DeclarationParserTest.java |  9 ++-
 .../source/tree/java/PsiModifierListTest.java | 56 ----------------
 .../src/messages/InspectionsBundle.properties |  3 -
 .../DeprecatedDefenderSyntax.html             |  6 --
 resources/src/META-INF/IdeaPlugin.xml         |  7 +-
 31 files changed, 67 insertions(+), 290 deletions(-)
 delete mode 100644 java/java-impl/src/com/intellij/codeInspection/deprecation/DeprecatedDefenderSyntaxInspection.java
 delete mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java
 delete mode 100644 java/java-tests/testData/psi/parser-partial/declarations/Unclosed9.txt
 delete mode 100644 java/java-tests/testSrc/com/intellij/psi/impl/source/tree/java/PsiModifierListTest.java
 delete mode 100644 resources-en/src/inspectionDescriptions/DeprecatedDefenderSyntax.html

diff --git a/java/java-impl/src/com/intellij/codeInspection/deprecation/DeprecatedDefenderSyntaxInspection.java b/java/java-impl/src/com/intellij/codeInspection/deprecation/DeprecatedDefenderSyntaxInspection.java
deleted file mode 100644
index 1a9024d14e9f..000000000000
--- a/java/java-impl/src/com/intellij/codeInspection/deprecation/DeprecatedDefenderSyntaxInspection.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * 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.codeInspection.deprecation;
-
-import com.intellij.codeInspection.*;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.*;
-import com.intellij.psi.impl.source.PsiModifierListImpl;
-import com.intellij.psi.util.PsiUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-// todo[r.sh] drop this after transition period finished
-public class DeprecatedDefenderSyntaxInspection extends BaseJavaLocalInspectionTool {
-  private final LocalQuickFix myQuickFix = new MyQuickFix();
-
-  @Nullable
-  @Override
-  public ProblemDescriptor[] checkMethod(@NotNull PsiMethod method, @NotNull InspectionManager manager, boolean isOnTheFly) {
-    final PsiJavaToken marker = PsiModifierListImpl.findExtensionMethodMarker(method);
-    return marker == null ? null : new ProblemDescriptor[]{
-      manager.createProblemDescriptor(marker, getDisplayName(), myQuickFix, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, isOnTheFly)
-    };
-  }
-
-  private static class MyQuickFix implements LocalQuickFix {
-    @NotNull
-    @Override
-    public String getName() {
-      return InspectionsBundle.message("deprecated.defender.syntax.fix");
-    }
-
-    @NotNull
-    @Override
-    public String getFamilyName() {
-      return "";
-    }
-
-    @Override
-    public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
-      final PsiElement marker = descriptor.getPsiElement();
-      if (marker != null && PsiUtil.isJavaToken(marker, JavaTokenType.DEFAULT_KEYWORD)) {
-        final PsiElement parent = marker.getParent();
-        if (parent instanceof PsiMethod) {
-          marker.delete();
-          final PsiMethod method = (PsiMethod)parent;
-          if (!method.hasModifierProperty(PsiModifier.DEFAULT)) {
-            PsiUtil.setModifierProperty(method, PsiModifier.DEFAULT, true);
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/java/java-psi-impl/src/com/intellij/lang/java/parser/DeclarationParser.java b/java/java-psi-impl/src/com/intellij/lang/java/parser/DeclarationParser.java
index 8722c92feb8e..f25e1ddf1109 100644
--- a/java/java-psi-impl/src/com/intellij/lang/java/parser/DeclarationParser.java
+++ b/java/java-psi-impl/src/com/intellij/lang/java/parser/DeclarationParser.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -402,29 +402,26 @@ public class DeclarationParser {
     return Pair.create(modList, isEmpty);
   }
 
-  private PsiBuilder.Marker parseMethodFromLeftParenth(final PsiBuilder builder, final PsiBuilder.Marker declaration,
-                                                       final boolean anno, final boolean constructor) {
+  private PsiBuilder.Marker parseMethodFromLeftParenth(PsiBuilder builder, PsiBuilder.Marker declaration, boolean anno, boolean constructor) {
     parseParameterList(builder);
 
     eatBrackets(builder, constructor, "expected.semicolon");
 
     myParser.getReferenceParser().parseReferenceList(builder, JavaTokenType.THROWS_KEYWORD, JavaElementType.THROWS_LIST, JavaTokenType.COMMA);
 
-    final boolean hasDefault = expect(builder, JavaTokenType.DEFAULT_KEYWORD);
-    if (hasDefault && anno) {
+    if (anno && expect(builder, JavaTokenType.DEFAULT_KEYWORD)) {
       parseAnnotationValue(builder);
     }
 
-    final IElementType tokenType = builder.getTokenType();
-    final boolean hasError = tokenType != JavaTokenType.SEMICOLON && tokenType != JavaTokenType.LBRACE;
-    if (hasError) {
-      final PsiBuilder.Marker error = builder.mark();
+    IElementType tokenType = builder.getTokenType();
+    if (tokenType != JavaTokenType.SEMICOLON && tokenType != JavaTokenType.LBRACE) {
+      PsiBuilder.Marker error = builder.mark();
       // heuristic: going to next line obviously means method signature is over, starting new method (actually, another one completion hack)
-      final CharSequence text = builder.getOriginalText();
+      CharSequence text = builder.getOriginalText();
       Loop:
       while (true) {
         for (int i = builder.getCurrentOffset() - 1; i >= 0; i--) {
-          final char ch = text.charAt(i);
+          char ch = text.charAt(i);
           if (ch == '\n') break Loop;
           else if (ch != ' ' && ch != '\t') break;
         }
@@ -433,11 +430,10 @@ public class DeclarationParser {
       error.error(JavaErrorMessages.message("expected.lbrace.or.semicolon"));
     }
 
-    if (hasDefault && !anno && !hasError && builder.getTokenType() != JavaTokenType.LBRACE) {
-      error(builder, JavaErrorMessages.message("expected.lbrace"));
-    }
-    if (!expect(builder, JavaTokenType.SEMICOLON) && builder.getTokenType() == JavaTokenType.LBRACE) {
-      myParser.getStatementParser().parseCodeBlock(builder);
+    if (!expect(builder, JavaTokenType.SEMICOLON)) {
+      if (builder.getTokenType() == JavaTokenType.LBRACE) {
+        myParser.getStatementParser().parseCodeBlock(builder);
+      }
     }
 
     done(declaration, anno ? JavaElementType.ANNOTATION_METHOD : JavaElementType.METHOD);
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
index a311b48a80dd..e0c09866c813 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/cache/RecordUtil.java
@@ -18,9 +18,10 @@ package com.intellij.psi.impl.cache;
 import com.intellij.lang.LighterAST;
 import com.intellij.lang.LighterASTNode;
 import com.intellij.lang.LighterASTTokenNode;
-import com.intellij.psi.*;
+import com.intellij.psi.JavaTokenType;
+import com.intellij.psi.PsiModifier;
+import com.intellij.psi.PsiModifierList;
 import com.intellij.psi.impl.java.stubs.*;
-import com.intellij.psi.impl.java.stubs.impl.PsiMethodStubImpl;
 import com.intellij.psi.impl.source.tree.JavaElementType;
 import com.intellij.psi.impl.source.tree.LightTreeUtil;
 import com.intellij.psi.stubs.PsiFileStub;
@@ -110,12 +111,7 @@ public class RecordUtil {
       else if (parent instanceof PsiMethodStub) {
         if (grandParent instanceof PsiClassStub && ((PsiClassStub)grandParent).isInterface()) {
           packed |= ModifierFlags.PUBLIC_MASK;
-          if (parent instanceof PsiMethodStubImpl && ((PsiMethodStubImpl)parent).hasExtensionMethodMark()) {
-            packed |= ModifierFlags.DEFENDER_MASK;
-          }
-          else {
-            packed |= ModifierFlags.ABSTRACT_MASK;
-          }
+          packed |= ModifierFlags.ABSTRACT_MASK;
         }
       }
       else if (parent instanceof PsiFieldStub) {
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaMethodElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaMethodElementType.java
index ba18473db823..409c340981f0 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaMethodElementType.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaMethodElementType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -73,7 +73,6 @@ public abstract class JavaMethodElementType extends JavaStubElementType<PsiMetho
     boolean isVarArgs = false;
     boolean isDeprecatedByComment = false;
     boolean hasDeprecatedAnnotation = false;
-    boolean isExtension = false;
     String defValueText = null;
 
     boolean expectingDef = false;
@@ -103,24 +102,18 @@ public abstract class JavaMethodElementType extends JavaStubElementType<PsiMetho
       else if (type == JavaTokenType.DEFAULT_KEYWORD) {
         expectingDef = true;
       }
-      else if (expectingDef && !ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(type) && type != JavaTokenType.SEMICOLON) {
-        if (type != JavaElementType.CODE_BLOCK) {
-          defValueText = LightTreeUtil.toFilteredString(tree, child, null);
-        }
-        else {
-          isExtension = true;
-        }
+      else if (expectingDef && !ElementType.JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(type) &&
+               type != JavaTokenType.SEMICOLON && type != JavaElementType.CODE_BLOCK) {
+        defValueText = LightTreeUtil.toFilteredString(tree, child, null);
         break;
       }
     }
 
-    final TypeInfo typeInfo = isConstructor ? TypeInfo.createConstructorType() : TypeInfo.create(tree, node, parentStub);
-    final boolean isAnno = (node.getTokenType() == JavaElementType.ANNOTATION_METHOD);
-    final byte flags = PsiMethodStubImpl.packFlags(isConstructor, isAnno, isVarArgs, isDeprecatedByComment, hasDeprecatedAnnotation);
+    TypeInfo typeInfo = isConstructor ? TypeInfo.createConstructorType() : TypeInfo.create(tree, node, parentStub);
+    boolean isAnno = (node.getTokenType() == JavaElementType.ANNOTATION_METHOD);
+    byte flags = PsiMethodStubImpl.packFlags(isConstructor, isAnno, isVarArgs, isDeprecatedByComment, hasDeprecatedAnnotation);
 
-    final PsiMethodStubImpl stub = new PsiMethodStubImpl(parentStub, StringRef.fromString(name), typeInfo, flags, StringRef.fromString(defValueText));
-    stub.setExtensionMethodMark(isExtension);
-    return stub;
+    return new PsiMethodStubImpl(parentStub, StringRef.fromString(name), typeInfo, flags, StringRef.fromString(defValueText));
   }
 
   @Override
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiMethodStubImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiMethodStubImpl.java
index f5c6a4bb5591..a7c07553bc16 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiMethodStubImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/impl/PsiMethodStubImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -37,8 +37,6 @@ public class PsiMethodStubImpl extends StubBase<PsiMethod> implements PsiMethodS
   private final byte myFlags;
   private final StringRef myName;
   private StringRef myDefaultValueText;
-  // todo[r.sh] drop this after transition period finished
-  private boolean myHasExtMethodMark = false;
 
   private static final int CONSTRUCTOR = 0x01;
   private static final int VARARGS = 0x02;
@@ -74,14 +72,6 @@ public class PsiMethodStubImpl extends StubBase<PsiMethod> implements PsiMethodS
     myReturnType = returnType;
   }
 
-  public void setExtensionMethodMark(boolean hasExtMethodMark) {
-    myHasExtMethodMark = hasExtMethodMark;
-  }
-
-  public boolean hasExtensionMethodMark() {
-    return myHasExtMethodMark;
-  }
-
   @Override
   public boolean isConstructor() {
     return (myFlags & CONSTRUCTOR) != 0;
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java
index 9e8145fa25a3..97880519a6a0 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/PsiModifierListImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -30,15 +30,12 @@ import com.intellij.psi.impl.source.tree.Factory;
 import com.intellij.psi.impl.source.tree.TreeElement;
 import com.intellij.psi.impl.source.tree.java.PsiAnnotationImpl;
 import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.THashMap;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 import java.util.Map;
@@ -134,12 +131,9 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
           return false;
         }
         if (type == JavaTokenType.ABSTRACT_KEYWORD) {
-          return !(getNode().findChildByType(JavaTokenType.DEFAULT_KEYWORD) != null || findExtensionMethodMarker((PsiMethod)parent) != null);
+          return getNode().findChildByType(JavaTokenType.DEFAULT_KEYWORD) == null;
         }
       }
-      if (type == JavaTokenType.DEFAULT_KEYWORD && findExtensionMethodMarker((PsiMethod)parent) != null) {
-        return true;
-      }
     }
     else if (parent instanceof PsiField) {
       if (parent instanceof PsiEnumConstant) {
@@ -179,16 +173,6 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
     return getNode().findChildByType(type) != null;
   }
 
-  @Nullable
-  public static PsiJavaToken findExtensionMethodMarker(@Nullable PsiMethod method) {
-    // todo[r.sh] drop this after transition period finished
-    if (method == null) return null;
-    final PsiCodeBlock body = method.getBody();
-    if (body == null) return null;
-    final PsiElement previous = PsiTreeUtil.skipSiblingsBackward(body, PsiComment.class, PsiWhiteSpace.class);
-    return previous instanceof PsiJavaToken && PsiUtil.isJavaToken(previous, JavaTokenType.DEFAULT_KEYWORD) ? (PsiJavaToken)previous : null;
-  }
-
   @Override
   public boolean hasExplicitModifier(@NotNull String name) {
     final CompositeElement tree = (CompositeElement)getNode();
@@ -234,7 +218,6 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
       }
       else if (parent instanceof PsiMethod && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) {
         if (type == JavaTokenType.PUBLIC_KEYWORD || type == JavaTokenType.ABSTRACT_KEYWORD) return;
-        if (type == JavaTokenType.DEFAULT_KEYWORD && findExtensionMethodMarker((PsiMethod)parent) != null) return;
       }
       else if (parent instanceof PsiClass && grandParent instanceof PsiClass && ((PsiClass)grandParent).isInterface()) {
         if (type == JavaTokenType.PUBLIC_KEYWORD) return;
@@ -257,13 +240,6 @@ public class PsiModifierListImpl extends JavaStubPsiElement<PsiModifierListStub>
       if (child != null) {
         SourceTreeToPsiMap.treeToPsiNotNull(child).delete();
       }
-
-      if (type == JavaTokenType.DEFAULT_KEYWORD && parent instanceof PsiMethod) {
-        final PsiJavaToken marker = findExtensionMethodMarker((PsiMethod)parent);
-        if (marker != null) {
-          marker.delete();
-        }
-      }
     }
   }
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/UnsupportedFeatures.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/UnsupportedFeatures.java
index d2635c297368..b3bdd17d9a7b 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/UnsupportedFeatures.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/UnsupportedFeatures.java
@@ -44,6 +44,6 @@ class UnsupportedFeatures {
   }
 
   interface I {
-    <error descr="Extension methods are not supported at this language level">void m() default { }</error>
+    <error descr="Extension methods are not supported at this language level">default void m() { }</error>
   }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DefaultMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DefaultMethod.java
index 2f886ff034bf..18e7630abdd5 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DefaultMethod.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/DefaultMethod.java
@@ -1,10 +1,11 @@
 class Test {
   public static final BinaryOperator<Integer> rPlus = (x, y) -> x + y;
+
   interface BinaryOperator<T> extends Combiner<T,T,T> {
     public T operate(T left, T right);
 
     @Override
-    T combine(T t1, T t2) default {
+    default T combine(T t1, T t2) {
       return operate(t1, t2);
     }
   }
@@ -13,5 +14,3 @@ class Test {
     V combine(T t, U u);
   }
 }
-
-
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java
deleted file mode 100644
index a5e0917301b6..000000000000
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethodSyntax.java
+++ /dev/null
@@ -1,8 +0,0 @@
-interface I {
-  void m1() <error descr="Deprecated extension method syntax">default</error> { }
-
-  default void m2() <error descr="Deprecated extension method syntax">default</error> { }
-
-  @SuppressWarnings("extensionSyntax")
-  void m3() default { }
-}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java
index 44a2a1aaf39f..8c6bc7e3815d 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/interfaceMethods/ExtensionMethods.java
@@ -17,11 +17,11 @@
 class C {
   interface I {
     int i = 42;
-    void m() default { }
+    default void m() { }
   }
 
   interface II extends I {
-    void m() default {
+    default void m() {
       I.super.m();
       <error descr="Unqualified super reference is not allowed in extension method">super.m</error>();
 
@@ -46,18 +46,18 @@ class C {
 }
 
 class D {
-  <error descr="Extension methods can only be used within an interface">void m()</error> default { }
+  <error descr="Extension methods can only be used within an interface">default void m()</error> { }
 }
 
 interface IllegalMods {
-  <error descr="Static methods in interfaces should have a body">static void m1()</error>;
-  <error descr="Illegal combination of modifiers: 'static' and 'default'">static</error> void m2() default { }
+  void m1()<error descr="'{' or ';' expected"> </error>default<error descr="Identifier or type expected">;</error> <error descr="Not allowed in interface">{ }</error>
+
+  <error descr="Static methods in interfaces should have a body">static void m2()</error>;
   <error descr="Illegal combination of modifiers: 'static' and 'default'">static</error> <error descr="Illegal combination of modifiers: 'default' and 'static'">default</error> void m3() { }
 
-  <error descr="Illegal combination of modifiers: 'abstract' and 'default'">abstract</error> void m4() default { }
-  <error descr="Illegal combination of modifiers: 'abstract' and 'default'">abstract</error> <error descr="Illegal combination of modifiers: 'default' and 'abstract'">default</error> void m5() { }
+  <error descr="Illegal combination of modifiers: 'abstract' and 'default'">abstract</error> <error descr="Illegal combination of modifiers: 'default' and 'abstract'">default</error> void m4() { }
 
-  <error descr="Extension method should have a body">default void m6()</error>;
+  <error descr="Extension method should have a body">default void m5()</error>;
 
   <error descr="Modifier 'default' not allowed here">default</error> int i;
   <error descr="Modifier 'default' not allowed here">default</error> interface X { }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/Wildcards.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/Wildcards.java
index e0c099fc2fa5..9025631f6e90 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/Wildcards.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/Wildcards.java
@@ -1,6 +1,6 @@
 import java.util.*;
 
-class MyTest2{
+class MyTest2 {
     {
         Comparator<? super String> comparator = String::compareToIgnoreCase;
     }
@@ -16,5 +16,5 @@ interface Foo2<T> {
     void bar(T i, T j);
 }
 interface Bar2 {
-    public void xxx(Bar2 p) default {}
+    default void xxx(Bar2 p) { }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterQualifiedThis.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterQualifiedThis.java
index 2b40ee0dc77c..d6eb617f8e25 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterQualifiedThis.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterQualifiedThis.java
@@ -7,7 +7,7 @@ class Test {
   interface InOut<A> {
     A run() throws IOException;
 
-    <B> InOut<B> bind(final Eff<A, InOut<B>> f) default {
+    default <B> InOut<B> bind(final Eff<A, InOut<B>> f) {
       return () -> f.f(InOut.this.run()).run();
     }
   }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeQualifiedThis.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeQualifiedThis.java
index a23bd4099c2e..fee0aa6d65dd 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeQualifiedThis.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/beforeQualifiedThis.java
@@ -7,7 +7,7 @@ class Test {
   interface InOut<A> {
     A run() throws IOException;
 
-    <B> InOut<B> bind(final Eff<A, InOut<B>> f) default {
+    default <B> InOut<B> bind(final Eff<A, InOut<B>> f) {
       return new In<caret>Out<B>() {
         @Override
         public B run() throws IOException {
diff --git a/java/java-tests/testData/codeInsight/overrideImplement/afterDoNotImplementExtensionMethods.java b/java/java-tests/testData/codeInsight/overrideImplement/afterDoNotImplementExtensionMethods.java
index f32bf532f932..04dfc07497fe 100644
--- a/java/java-tests/testData/codeInsight/overrideImplement/afterDoNotImplementExtensionMethods.java
+++ b/java/java-tests/testData/codeInsight/overrideImplement/afterDoNotImplementExtensionMethods.java
@@ -4,7 +4,7 @@ interface A<T> {
 }
 
 interface B<T> extends A<T> {
-    void m1(T t) default { }
+    default void m1(T t) { }
 }
 
 class MyClass<T> implements B<T> {
diff --git a/java/java-tests/testData/codeInsight/overrideImplement/afterImplementExtensionMethods.java b/java/java-tests/testData/codeInsight/overrideImplement/afterImplementExtensionMethods.java
index 47e572e164d5..6e86a4ed3d62 100644
--- a/java/java-tests/testData/codeInsight/overrideImplement/afterImplementExtensionMethods.java
+++ b/java/java-tests/testData/codeInsight/overrideImplement/afterImplementExtensionMethods.java
@@ -1,5 +1,5 @@
 interface A<T> {
-    void m(T t) default { }
+    default void m(T t) { }
 }
 
 class MyClass<T> implements A<T> {
diff --git a/java/java-tests/testData/codeInsight/overrideImplement/beforeDoNotImplementExtensionMethods.java b/java/java-tests/testData/codeInsight/overrideImplement/beforeDoNotImplementExtensionMethods.java
index edf7c570c383..4d2638093804 100644
--- a/java/java-tests/testData/codeInsight/overrideImplement/beforeDoNotImplementExtensionMethods.java
+++ b/java/java-tests/testData/codeInsight/overrideImplement/beforeDoNotImplementExtensionMethods.java
@@ -4,7 +4,7 @@ interface A<T> {
 }
 
 interface B<T> extends A<T> {
-    void m1(T t) default { }
+    default void m1(T t) { }
 }
 
 class MyClass<T> implements B<T> {
diff --git a/java/java-tests/testData/codeInsight/overrideImplement/beforeImplementExtensionMethods.java b/java/java-tests/testData/codeInsight/overrideImplement/beforeImplementExtensionMethods.java
index 0694873d6618..40920991631c 100644
--- a/java/java-tests/testData/codeInsight/overrideImplement/beforeImplementExtensionMethods.java
+++ b/java/java-tests/testData/codeInsight/overrideImplement/beforeImplementExtensionMethods.java
@@ -1,5 +1,5 @@
 interface A<T> {
-    void m(T t) default { }
+    default void m(T t) { }
 }
 
 class MyClass<T> implements A<T> {
diff --git a/java/java-tests/testData/psi/parser-partial/declarations/Extension.txt b/java/java-tests/testData/psi/parser-partial/declarations/Extension.txt
index 8e876a4d19a3..7c961cf1bb7e 100644
--- a/java/java-tests/testData/psi/parser-partial/declarations/Extension.txt
+++ b/java/java-tests/testData/psi/parser-partial/declarations/Extension.txt
@@ -2,10 +2,11 @@ PsiJavaFile:Extension.java
   PsiJavaToken:LBRACE('{')
   PsiWhiteSpace(' ')
   PsiMethod:f
-    PsiModifierList:
-      <empty list>
+    PsiModifierList:default
+      PsiKeyword:default('default')
     PsiTypeParameterList
       <empty list>
+    PsiWhiteSpace(' ')
     PsiTypeElement:int
       PsiKeyword:int('int')
     PsiWhiteSpace(' ')
@@ -22,8 +23,6 @@ PsiJavaFile:Extension.java
         PsiReferenceParameterList
           <empty list>
     PsiWhiteSpace(' ')
-    PsiKeyword:default('default')
-    PsiWhiteSpace(' ')
     PsiCodeBlock
       PsiJavaToken:LBRACE('{')
       PsiWhiteSpace(' ')
@@ -36,4 +35,4 @@ PsiJavaFile:Extension.java
       PsiWhiteSpace(' ')
       PsiJavaToken:RBRACE('}')
   PsiWhiteSpace(' ')
-  PsiJavaToken:RBRACE('}')
+  PsiJavaToken:RBRACE('}')
\ No newline at end of file
diff --git a/java/java-tests/testData/psi/parser-partial/declarations/Unclosed8.txt b/java/java-tests/testData/psi/parser-partial/declarations/Unclosed8.txt
index 5505b83c9a2c..4229dd3dba31 100644
--- a/java/java-tests/testData/psi/parser-partial/declarations/Unclosed8.txt
+++ b/java/java-tests/testData/psi/parser-partial/declarations/Unclosed8.txt
@@ -15,9 +15,12 @@ PsiJavaFile:Unclosed8.java
       PsiJavaToken:RPARENTH(')')
     PsiReferenceList
       <empty list>
-    PsiWhiteSpace(' ')
-    PsiKeyword:default('default')
     PsiErrorElement:'{' or ';' expected
       <empty list>
   PsiWhiteSpace(' ')
-  PsiJavaToken:RBRACE('}')
+  PsiModifierList:default
+    PsiKeyword:default('default')
+  PsiErrorElement:Identifier or type expected
+    <empty list>
+  PsiWhiteSpace(' ')
+  PsiJavaToken:RBRACE('}')
\ No newline at end of file
diff --git a/java/java-tests/testData/psi/parser-partial/declarations/Unclosed9.txt b/java/java-tests/testData/psi/parser-partial/declarations/Unclosed9.txt
deleted file mode 100644
index e1df58f533ae..000000000000
--- a/java/java-tests/testData/psi/parser-partial/declarations/Unclosed9.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-PsiJavaFile:Unclosed9.java
-  PsiJavaToken:LBRACE('{')
-  PsiWhiteSpace(' ')
-  PsiMethod:f
-    PsiModifierList:
-      <empty list>
-    PsiTypeParameterList
-      <empty list>
-    PsiTypeElement:void
-      PsiKeyword:void('void')
-    PsiWhiteSpace(' ')
-    PsiIdentifier:f('f')
-    PsiParameterList:()
-      PsiJavaToken:LPARENTH('(')
-      PsiJavaToken:RPARENTH(')')
-    PsiReferenceList
-      <empty list>
-    PsiWhiteSpace(' ')
-    PsiKeyword:default('default')
-    PsiErrorElement:'{' expected
-      <empty list>
-    PsiWhiteSpace(' ')
-    PsiJavaToken:SEMICOLON(';')
-  PsiWhiteSpace(' ')
-  PsiJavaToken:RBRACE('}')
diff --git a/java/java-tests/testData/refactoring/pullUp/ExtensionMethod.java b/java/java-tests/testData/refactoring/pullUp/ExtensionMethod.java
index 46ec2115c20a..af8c9a927ee5 100644
--- a/java/java-tests/testData/refactoring/pullUp/ExtensionMethod.java
+++ b/java/java-tests/testData/refactoring/pullUp/ExtensionMethod.java
@@ -2,7 +2,7 @@ interface Base {
 }
 
 interface I2 extends Base {
-    void foo<caret>() default {
+    default void foo<caret>() {
         System.out.println("Hi there.");
     }
 }
\ No newline at end of file
diff --git a/java/java-tests/testData/refactoring/pullUp/ExtensionMethod_after.java b/java/java-tests/testData/refactoring/pullUp/ExtensionMethod_after.java
index 33876453d679..6cb516992266 100644
--- a/java/java-tests/testData/refactoring/pullUp/ExtensionMethod_after.java
+++ b/java/java-tests/testData/refactoring/pullUp/ExtensionMethod_after.java
@@ -1,5 +1,5 @@
 interface Base {
-    void foo() default {
+    default void foo() {
         System.out.println("Hi there.");
     }
 }
diff --git a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToClass.java b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToClass.java
index 2b074cb5374a..f296f9aa5747 100644
--- a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToClass.java
+++ b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToClass.java
@@ -1,5 +1,5 @@
 interface Base {
-    void foo<caret>() default {
+    default void foo<caret>() {
         System.out.println("Hi there.");
     }
 }
diff --git a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface.java b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface.java
index 7bf94eab2d8b..c864ac7ec317 100644
--- a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface.java
+++ b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface.java
@@ -1,5 +1,5 @@
 interface Base {
-    void foo<caret>() default {
+    default void foo<caret>() {
         System.out.println("Hi there.");
     }
 }
diff --git a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface_after.java b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface_after.java
index 4d5f9b73f345..e1aeac56bdaf 100644
--- a/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface_after.java
+++ b/java/java-tests/testData/refactoring/pushDown/ExtensionMethodToInterface_after.java
@@ -2,7 +2,7 @@ interface Base {
 }
 
 interface I2 extends Base {
-    void foo() default {
+    default void foo() {
         System.out.println("Hi there.");
     }
 }
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
index 1b158ef45779..dab1d6306e9b 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/Interface8MethodsHighlightingTest.java
@@ -16,7 +16,6 @@
 package com.intellij.codeInsight.daemon.lambda;
 
 import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
-import com.intellij.codeInspection.deprecation.DeprecatedDefenderSyntaxInspection;
 import org.jetbrains.annotations.NonNls;
 
 public class Interface8MethodsHighlightingTest extends LightDaemonAnalyzerTestCase {
@@ -31,11 +30,6 @@ public class Interface8MethodsHighlightingTest extends LightDaemonAnalyzerTestCa
   public void testStaticMethodsInFunctionalInterface() { doTest(false, false); }
   public void testCyclicSubstitutor() { doTest(false, false); }
 
-  public void testExtensionMethodSyntax() {
-    enableInspectionTools(DeprecatedDefenderSyntaxInspection.class);
-    doTest(true, false);
-  }
-
   private void doTest() {
     doTest(false, false);
   }
diff --git a/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/DeclarationParserTest.java b/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/DeclarationParserTest.java
index f79d868caa68..5570590a19f6 100644
--- a/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/DeclarationParserTest.java
+++ b/java/java-tests/testSrc/com/intellij/lang/java/parser/partial/DeclarationParserTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -79,7 +79,7 @@ public class DeclarationParserTest extends JavaParsingTestCase {
   public void testMethodNormal2() { doParserTest("{ default public void f() { } }", false, false); }
   public void testSemicolons() { doParserTest("{ void f() {}; void g() {}; }", false, false); }
   public void testUnclosed0() { doParserTest("{ void f() }", false, false); }
-  public void testExtension() { doParserTest("{ int f() throws E default { return 42; } }", false, false); }
+  public void testExtension() { doParserTest("{ default int f() throws E { return 42; } }", false, false); }
   public void testUnclosed1() { doParserTest("{ void f( }", false, false); }
   public void testUnclosed2() { doParserTest("{ void f()\n void g(); }", false, false); }
   public void testUnclosed3() { doParserTest("{ void f(int a }", false, false); }
@@ -88,7 +88,6 @@ public class DeclarationParserTest extends JavaParsingTestCase {
   public void testUnclosed6() { doParserTest("{ void f() default ; }", true, false); }
   public void testUnclosed7() { doParserTest("{ void f() default {return 42;} }", true, false); }
   public void testUnclosed8() { doParserTest("{ void f() default }", false, false); }
-  public void testUnclosed9() { doParserTest("{ void f() default ; }", false, false); }
   public void testConstructorBrackets() { doParserTest("{ A() [] { } }", false, false); }
   public void testVarArgBrackets() { doParserTest("{ void foo(int... x[]); }", false, false); }
 
@@ -104,7 +103,7 @@ public class DeclarationParserTest extends JavaParsingTestCase {
   public void testParameterAnnotation() { doParserTest("{ void foo (@Annotation(value=77) int param) {} }", false, false); }
   public void testParameterizedMethod() { doParserTest("{ @Nullable <T> T bar() {} }", false, false); }
 
-  private void doParserTest(final String text, final boolean isAnnotation, final boolean isEnum) {
+  private void doParserTest(String text, boolean isAnnotation, boolean isEnum) {
     doParserTest(text, new MyTestParser(isAnnotation, isEnum));
   }
 
@@ -118,7 +117,7 @@ public class DeclarationParserTest extends JavaParsingTestCase {
     }
 
     @Override
-    public void parse(final PsiBuilder builder) {
+    public void parse(PsiBuilder builder) {
       JavaParser.INSTANCE.getDeclarationParser().parseClassBodyWithBraces(builder, myAnnotation, myAnEnum);
     }
   }
diff --git a/java/java-tests/testSrc/com/intellij/psi/impl/source/tree/java/PsiModifierListTest.java b/java/java-tests/testSrc/com/intellij/psi/impl/source/tree/java/PsiModifierListTest.java
deleted file mode 100644
index e94775bc951d..000000000000
--- a/java/java-tests/testSrc/com/intellij/psi/impl/source/tree/java/PsiModifierListTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * 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.psi.impl.source.tree.java;
-
-import com.intellij.ide.highlighter.JavaFileType;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiJavaFile;
-import com.intellij.psi.PsiMethod;
-import com.intellij.psi.PsiModifier;
-import com.intellij.psi.codeStyle.CodeStyleManager;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
-
-public class PsiModifierListTest extends LightCodeInsightFixtureTestCase {
-  // todo[r.sh] drop this after transition period finished
-  public void testDefaultModifier() throws Exception {
-    final PsiFile file = myFixture.configureByText(JavaFileType.INSTANCE,
-                                             "class C {\n" +
-                                             "    default void m() default {\n" +
-                                             "    }\n" +
-                                             "}");
-    final PsiMethod method = ((PsiJavaFile)file).getClasses()[0].getMethods()[0];
-    assertEquals("default void m() default {\n    }", method.getText());
-
-    ApplicationManager.getApplication().runWriteAction(new Runnable() {
-      @Override
-      public void run() {
-        PsiUtil.setModifierProperty(method, PsiModifier.DEFAULT, false);
-        CodeStyleManager.getInstance(getProject()).reformat(method);
-      }
-    });
-    assertEquals("void m() {\n    }", method.getText());
-
-    ApplicationManager.getApplication().runWriteAction(new Runnable() {
-      @Override
-      public void run() {
-        PsiUtil.setModifierProperty(method, PsiModifier.DEFAULT, true);
-      }
-    });
-    assertEquals("default void m() {\n    }", method.getText());
-  }
-}
diff --git a/platform/platform-resources-en/src/messages/InspectionsBundle.properties b/platform/platform-resources-en/src/messages/InspectionsBundle.properties
index 663c46229631..7a46095733ea 100644
--- a/platform/platform-resources-en/src/messages/InspectionsBundle.properties
+++ b/platform/platform-resources-en/src/messages/InspectionsBundle.properties
@@ -670,9 +670,6 @@ inspection.redirect.template=<html><body>Injected element has problem: {0} (in <
 nothing.found=Nothing found
 special.annotations.list.annotation.pattern=Add Annotations Pattern
 
-deprecated.defender.syntax.description=Deprecated extension method syntax
-deprecated.defender.syntax.fix=Convert extension method syntax
-
 inspection.variable.assigned.to.itself.display.name=Variable is assigned to itself
 assignment.to.itself.problem.descriptor=Variable ''{0}'' is assigned to itself
 assignment.to.declared.variable.problem.descriptor=Variable ''{0}'' is initialized with self assignment
diff --git a/resources-en/src/inspectionDescriptions/DeprecatedDefenderSyntax.html b/resources-en/src/inspectionDescriptions/DeprecatedDefenderSyntax.html
deleted file mode 100644
index b82bf836209c..000000000000
--- a/resources-en/src/inspectionDescriptions/DeprecatedDefenderSyntax.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<html xmlns="http://www.w3.org/1999/html">
-<body>
-Detects deprecated extension method syntax: <pre>void m() default { }</pre>
-Allows to convert it to the correct form: <pre>default void m() { }</pre>
-</body>
-</html>
\ No newline at end of file
diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml
index 3c635fe04277..b862a92ee514 100644
--- a/resources/src/META-INF/IdeaPlugin.xml
+++ b/resources/src/META-INF/IdeaPlugin.xml
@@ -372,7 +372,7 @@
 
     <applicationService serviceInterface="com.intellij.psi.JavaDirectoryService"
                         serviceImplementation="com.intellij.psi.impl.file.JavaDirectoryServiceImpl"/>
-    
+
     <applicationService serviceInterface="com.intellij.openapi.projectRoots.JavaVersionService"
                         serviceImplementation="com.intellij.openapi.projectRoots.JavaVersionServiceImpl"/>
 
@@ -518,9 +518,6 @@
     <localInspection language="JAVA" suppressId="deprecation" shortName="Deprecation" displayName="Deprecated API usage" groupName=""
                      enabledByDefault="true" level="WARNING"
                      implementationClass="com.intellij.codeInspection.deprecation.DeprecationInspection"/>
-    <localInspection language="JAVA" suppressId="extensionSyntax" bundle="messages.InspectionsBundle" key="deprecated.defender.syntax.description"
-                     groupName="" enabledByDefault="true" level="ERROR"
-                     implementationClass="com.intellij.codeInspection.deprecation.DeprecatedDefenderSyntaxInspection"/>
     <localInspection language="XML" shortName="DeprecatedClassUsageInspection" displayName="Deprecated API usage in XML" groupName="XML"
                      enabledByDefault="true" level="WARNING" implementationClass="com.intellij.util.xml.DeprecatedClassUsageInspection"/>
     <localInspection language="JAVA" shortName="EqualsAndHashcode" bundle="messages.InspectionsBundle" key="inspection.equals.hashcode.display.name"
@@ -859,7 +856,7 @@
     <lang.whiteSpaceFormattingStrategy language="JAVA"
                                        implementationClass="com.intellij.psi.formatter.JavadocWhiteSpaceFormattingStrategy"/>
     <lang.rearranger language="JAVA" implementationClass="com.intellij.psi.codeStyle.arrangement.JavaRearranger"/>
-    
+
     <lang.documentationProvider language="JAVA" implementationClass="com.intellij.lang.java.JavaDocumentationProvider"/>
     <documentationProvider implementation="com.intellij.lang.java.FileDocumentationProvider" order="last"/>
     <lang.documentationFixer language="JAVA" implementationClass="com.intellij.codeInsight.documentation.JavaDocCommentFixer"/>

From 3a7aec2e78b6081328160e137f1c483db8a718d0 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 20:51:57 +0100
Subject: [PATCH 311/354] Test data fixed

---
 .../throws_runtime_exception/MoveThrows.java   | 18 ++++++++++++++++++
 .../throws_runtime_exception/moveThrows.java   |  3 ---
 ...hrowsRuntimeExceptionInspectionFixTest.java |  4 +---
 3 files changed, 19 insertions(+), 6 deletions(-)
 create mode 100644 plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
 delete mode 100644 plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/moveThrows.java

diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
new file mode 100644
index 000000000000..08723c03b257
--- /dev/null
+++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2000-2013 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.
+ */
+class C {
+  void foo() throws RuntimeException<caret> {}
+}
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/moveThrows.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/moveThrows.java
deleted file mode 100644
index ea95fddcf155..000000000000
--- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/moveThrows.java
+++ /dev/null
@@ -1,3 +0,0 @@
-class C {
-  void foo() throws RuntimeException<caret> {}
-}
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/fixes/errorhandling/ThrowsRuntimeExceptionInspectionFixTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/fixes/errorhandling/ThrowsRuntimeExceptionInspectionFixTest.java
index 500d8244adad..0b29ddfd081a 100644
--- a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/fixes/errorhandling/ThrowsRuntimeExceptionInspectionFixTest.java
+++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/fixes/errorhandling/ThrowsRuntimeExceptionInspectionFixTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -17,8 +17,6 @@ package com.siyeh.ig.fixes.errorhandling;
 
 import com.siyeh.InspectionGadgetsBundle;
 import com.siyeh.ig.IGQuickFixesTestCase;
-import com.siyeh.ig.errorhandling.CaughtExceptionImmediatelyRethrownInspection;
-import com.siyeh.ig.errorhandling.EmptyFinallyBlockInspection;
 import com.siyeh.ig.errorhandling.ThrowsRuntimeExceptionInspection;
 
 public class ThrowsRuntimeExceptionInspectionFixTest extends IGQuickFixesTestCase {

From a0ac461a4ad9f4e8941c67ba6b8eddaf6cb5b8d3 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 21:05:18 +0100
Subject: [PATCH 312/354] Formatting

---
 .../application/impl/ApplicationInfoImpl.java        | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationInfoImpl.java b/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationInfoImpl.java
index b86ba528314a..68bfd928402b 100644
--- a/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationInfoImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationInfoImpl.java
@@ -64,7 +64,7 @@ public class ApplicationInfoImpl extends ApplicationInfoEx implements JDOMExtern
   @NonNls private String myToolWindowIconUrl = "/toolwindows/toolWindowProject.png";
   private String myWelcomeScreenLogoUrl = null;
   private String myEditorBackgroundImageUrl = null;
-  
+
   private Calendar myBuildDate = null;
   private Calendar myMajorReleaseBuildDate = null;
   private String myPackageCode = null;
@@ -416,9 +416,7 @@ public class ApplicationInfoImpl extends ApplicationInfoEx implements JDOMExtern
     if (ourShadowInstance == null) {
       ourShadowInstance = new ApplicationInfoImpl();
       try {
-        Document doc = JDOMUtil.loadDocument(ApplicationInfoImpl.class, IDEA_PATH +
-                                                                        ApplicationNamesInfo.getComponentName() +
-                                                                        XML_EXTENSION);
+        Document doc = JDOMUtil.loadDocument(ApplicationInfoImpl.class, IDEA_PATH + ApplicationNamesInfo.getComponentName() + XML_EXTENSION);
         ourShadowInstance.readExternal(doc.getRootElement());
       }
       catch (Exception e) {
@@ -496,7 +494,7 @@ public class ApplicationInfoImpl extends ApplicationInfoEx implements JDOMExtern
     Element aboutLogoElement = parentNode.getChild(ELEMENT_ABOUT);
     if (aboutLogoElement != null) {
       myAboutImageUrl = aboutLogoElement.getAttributeValue(ATTRIBUTE_URL);
-      
+
       String v = aboutLogoElement.getAttributeValue(ATTRIBUTE_ABOUT_FOREGROUND_COLOR);
       if (v != null) {
         myAboutForeground = parseColor(v);
@@ -559,10 +557,10 @@ public class ApplicationInfoImpl extends ApplicationInfoEx implements JDOMExtern
       if (webHelpUrl != null) {
         myWebHelpUrl = webHelpUrl;
       }
-      
+
       String attValue = helpElement.getAttributeValue(ATTRIBUTE_HAS_HELP);
       myHasHelp = attValue == null || Boolean.parseBoolean(attValue); // Default is true
-      
+
       attValue = helpElement.getAttributeValue(ATTRIBUTE_HAS_CONTEXT_HELP);
       myHasContextHelp = attValue == null || Boolean.parseBoolean(attValue); // Default is true
     }

From 5d67b504aaa3129c8c9ba18229abf5d04d10bfbf Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 21:05:26 +0100
Subject: [PATCH 313/354] Typo

---
 .../src/com/intellij/psi/impl/PsiDocumentManagerImpl.java | 7 +++----
 .../com/intellij/testFramework/LightPlatformTestCase.java | 8 ++++----
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
index 93a2277cc51d..3bb2fc689739 100644
--- a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -724,7 +724,7 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec
           LOG.error("Too many uncommitted documents for " + myProject + ":\n" + myUncommittedDocuments);
         }
         finally {
-          clearUncommitedDocuments();
+          clearUncommittedDocuments();
         }
       }
       commitAllDocuments();
@@ -803,7 +803,7 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec
   }
 
   @TestOnly
-  public void clearUncommitedDocuments() {
+  public void clearUncommittedDocuments() {
     myUncommittedDocuments.clear();
     mySynchronizer.cleanupForNextTest();
     myDocumentCommitThread.clearQueue();
@@ -813,7 +813,6 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec
     return mySynchronizer;
   }
 
-
   @Override
   public void save() {
     // Ensure all documents are committed on save so file content dependent indices, that use PSI to build have consistent content.
diff --git a/platform/testFramework/src/com/intellij/testFramework/LightPlatformTestCase.java b/platform/testFramework/src/com/intellij/testFramework/LightPlatformTestCase.java
index d774b1081859..09702d3c2a47 100644
--- a/platform/testFramework/src/com/intellij/testFramework/LightPlatformTestCase.java
+++ b/platform/testFramework/src/com/intellij/testFramework/LightPlatformTestCase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -589,18 +589,18 @@ public abstract class LightPlatformTestCase extends UsefulTestCase implements Da
     if (isLight(project)) {
       // mark temporarily as disposed so that rogue component trying to access it will fail
       ((ProjectImpl)project).setTemporarilyDisposed(true);
-      documentManager.clearUncommitedDocuments();
+      documentManager.clearUncommittedDocuments();
     }
   }
 
   public static PsiDocumentManagerImpl clearUncommittedDocuments(@NotNull Project project) {
     PsiDocumentManagerImpl documentManager = (PsiDocumentManagerImpl)PsiDocumentManager.getInstance(project);
-    documentManager.clearUncommitedDocuments();
+    documentManager.clearUncommittedDocuments();
 
     ProjectManagerImpl projectManager = (ProjectManagerImpl)ProjectManager.getInstance();
     if (projectManager.isDefaultProjectInitialized()) {
       Project defaultProject = projectManager.getDefaultProject();
-      ((PsiDocumentManagerImpl)PsiDocumentManager.getInstance(defaultProject)).clearUncommitedDocuments();
+      ((PsiDocumentManagerImpl)PsiDocumentManager.getInstance(defaultProject)).clearUncommittedDocuments();
     }
     return documentManager;
   }

From ffb2372dabe4b33dc3c2d03d3d0a4df318907948 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Wed, 27 Feb 2013 21:10:05 +0100
Subject: [PATCH 314/354] Allow Mercurial tests to start on their own class
 path

---
 plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
index af5cad92bb72..b63ba4cde670 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.testFramework.LightPlatformTestCase;
+import com.intellij.testFramework.PlatformTestCase;
 
 import java.io.File;
 import java.io.IOException;
@@ -47,6 +48,11 @@ public abstract class HgPlatformTest extends LightPlatformTestCase {
   protected VirtualFile myProjectRoot;
   protected VirtualFile myRepository;
 
+  @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors")
+  protected HgPlatformTest() {
+    PlatformTestCase.initPlatformLangPrefix();
+  }
+
   @Override
   protected void setUp() throws Exception {
     super.setUp();

From 4e4e75dc83a5efc82a645fdafe495e9de16a99af Mon Sep 17 00:00:00 2001
From: Bas Leijdekkers <basleijdekkers@gmail.com>
Date: Wed, 27 Feb 2013 21:19:19 +0100
Subject: [PATCH 315/354] IDEA-101929 (Result of method is ignored warning: do
 not issue it when the statement is not complete)

---
 .../ig/bugs/IgnoreResultOfCallInspection.java | 34 ++++++++-----------
 .../bugs/IgnoreResultsOfReadInspection.java   | 23 -------------
 .../IgnoreResultOfCall.java                   | 10 ++++++
 .../bugs/ignore_result_of_call/expected.xml   |  9 +++++
 .../IgnoreResultOfCallInspectionTest.java     | 10 ++++++
 5 files changed, 44 insertions(+), 42 deletions(-)
 delete mode 100644 plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/IgnoreResultsOfReadInspection.java
 create mode 100644 plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/IgnoreResultOfCall.java
 create mode 100644 plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/expected.xml
 create mode 100644 plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/IgnoreResultOfCallInspectionTest.java

diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/IgnoreResultOfCallInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/IgnoreResultOfCallInspection.java
index 873a2407a5cc..c476f9a6af38 100644
--- a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/IgnoreResultOfCallInspection.java
+++ b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/IgnoreResultOfCallInspection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2011 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@ import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.psi.*;
 import com.intellij.psi.util.InheritanceUtil;
+import com.intellij.psi.util.PsiUtilCore;
 import com.intellij.util.ui.CheckBox;
 import com.siyeh.InspectionGadgetsBundle;
 import com.siyeh.ig.BaseInspection;
@@ -77,8 +78,7 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
   @Override
   @NotNull
   public String getDisplayName() {
-    return InspectionGadgetsBundle.message(
-      "result.of.method.call.ignored.display.name");
+    return InspectionGadgetsBundle.message("result.of.method.call.ignored.display.name");
   }
 
   @Override
@@ -86,9 +86,7 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
   public String buildErrorString(Object... infos) {
     final PsiClass containingClass = (PsiClass)infos[0];
     final String className = containingClass.getName();
-    return InspectionGadgetsBundle.message(
-      "result.of.method.call.ignored.problem.descriptor",
-      className);
+    return InspectionGadgetsBundle.message("result.of.method.call.ignored.problem.descriptor", className);
   }
 
   @Override
@@ -106,9 +104,9 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
   @Override
   public JComponent createOptionsPanel() {
     final JPanel panel = new JPanel(new BorderLayout());
-    final ListTable table = new ListTable(new ListWrappingTableModel(Arrays.asList(classNames, methodNamePatterns), InspectionGadgetsBundle
-      .message("result.of.method.call.ignored.class.column.title"), InspectionGadgetsBundle
-      .message("result.of.method.call.ignored.method.column.title")));
+    final ListTable table = new ListTable(new ListWrappingTableModel(
+      Arrays.asList(classNames, methodNamePatterns), InspectionGadgetsBundle.message("result.of.method.call.ignored.class.column.title"),
+      InspectionGadgetsBundle.message("result.of.method.call.ignored.method.column.title")));
     final JPanel tablePanel = UiUtils.createAddRemovePanel(table);
     final CheckBox checkBox =
       new CheckBox(InspectionGadgetsBundle.message("result.of.method.call.ignored.non.library.option"), this, "m_reportAllNonLibraryCalls");
@@ -130,15 +128,13 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
   private class IgnoreResultOfCallVisitor extends BaseInspectionVisitor {
 
     @Override
-    public void visitExpressionStatement(
-      @NotNull PsiExpressionStatement statement) {
+    public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) {
       super.visitExpressionStatement(statement);
       final PsiExpression expression = statement.getExpression();
       if (!(expression instanceof PsiMethodCallExpression)) {
         return;
       }
-      final PsiMethodCallExpression call =
-        (PsiMethodCallExpression)expression;
+      final PsiMethodCallExpression call = (PsiMethodCallExpression)expression;
       final PsiMethod method = call.resolveMethod();
       if (method == null || method.isConstructor()) {
         return;
@@ -151,13 +147,14 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
       if (aClass == null) {
         return;
       }
-      if (m_reportAllNonLibraryCalls &&
-          !LibraryUtil.classIsInLibrary(aClass)) {
+      if (PsiUtilCore.hasErrorElementChild(statement)) {
+        return;
+      }
+      if (m_reportAllNonLibraryCalls && !LibraryUtil.classIsInLibrary(aClass)) {
         registerMethodCallError(call, aClass);
         return;
       }
-      final PsiReferenceExpression methodExpression =
-        call.getMethodExpression();
+      final PsiReferenceExpression methodExpression = call.getMethodExpression();
       final String methodName = methodExpression.getReferenceName();
       if (methodName == null) {
         return;
@@ -176,8 +173,7 @@ public class IgnoreResultOfCallInspection extends BaseInspection {
       }
     }
 
-    private boolean methodNamesMatch(String methodName,
-                                     String methodNamePattern) {
+    private boolean methodNamesMatch(String methodName, String methodNamePattern) {
       Pattern pattern;
       if (patternCache != null) {
         pattern = patternCache.get(methodNamePattern);
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/IgnoreResultsOfReadInspection.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/IgnoreResultsOfReadInspection.java
deleted file mode 100644
index 010b97103504..000000000000
--- a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/IgnoreResultsOfReadInspection.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.siyeh.igtest.bugs;
-
-import java.io.*;
-
-public class IgnoreResultsOfReadInspection
-{
-    private void foo()
-    {
-        try
-        {
-            final FileInputStream stream = new FileInputStream("FOO");
-            final byte[] buffer = new byte[10];
-            stream.read(buffer);
-        }
-        catch(FileNotFoundException e)
-        {
-        }
-        catch(IOException e)
-        {
-        }
-
-    }
-}
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/IgnoreResultOfCall.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/IgnoreResultOfCall.java
new file mode 100644
index 000000000000..6dbce04ce831
--- /dev/null
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/IgnoreResultOfCall.java
@@ -0,0 +1,10 @@
+package com.siyeh.igtest.bugs.ignore_result_of_call;
+
+class IgnoreResultOfCall {
+
+  void foo(Object o, String s) {
+    o.equals(s);
+    o.equals()
+  }
+
+}
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/expected.xml b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/expected.xml
new file mode 100644
index 000000000000..7f64be4f9ef0
--- /dev/null
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ignore_result_of_call/expected.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problems>
+  <problem>
+    <file>IgnoreResultOfCall.java</file>
+    <line>6</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Result of method call ignored</problem_class>
+    <description>Result of &lt;code&gt;Object.equals()&lt;/code&gt; is ignored #loc</description>
+  </problem>
+</problems>
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/IgnoreResultOfCallInspectionTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/IgnoreResultOfCallInspectionTest.java
new file mode 100644
index 000000000000..9e575efebbac
--- /dev/null
+++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/IgnoreResultOfCallInspectionTest.java
@@ -0,0 +1,10 @@
+package com.siyeh.ig.bugs;
+
+import com.siyeh.ig.IGInspectionTestCase;
+
+public class IgnoreResultOfCallInspectionTest extends IGInspectionTestCase {
+
+  public void test() throws Exception {
+    doTest("com/siyeh/igtest/bugs/ignore_result_of_call", new IgnoreResultOfCallInspection());
+  }
+}
\ No newline at end of file

From d67b444e8c11b530b5e6ff243fefa245756306f3 Mon Sep 17 00:00:00 2001
From: Bas Leijdekkers <basleijdekkers@gmail.com>
Date: Wed, 27 Feb 2013 21:29:07 +0100
Subject: [PATCH 316/354] cleanup and test

---
 ...ltOfObjectAllocationIgnoredInspection.java | 25 +++++++------------
 .../ResultOfObjectAllocationIgnored.html      |  2 +-
 .../ResultOfObjectAllocationIgnored.java}     |  6 ++---
 .../expected.xml                              | 16 ++++++++++++
 ...ObjectAllocationIgnoredInspectionTest.java | 25 +++++++++++++++++++
 5 files changed, 54 insertions(+), 20 deletions(-)
 rename plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/{ResultOfObjectAllocationIgnoredInspection.java => result_of_object_allocation_ignored/ResultOfObjectAllocationIgnored.java} (60%)
 create mode 100644 plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/expected.xml
 create mode 100644 plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspectionTest.java

diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspection.java
index bb3c3d3cdc41..eace327f462d 100644
--- a/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspection.java
+++ b/plugins/InspectionGadgets/src/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2007 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,40 +23,33 @@ import com.siyeh.ig.BaseInspection;
 import com.siyeh.ig.BaseInspectionVisitor;
 import org.jetbrains.annotations.NotNull;
 
-public class ResultOfObjectAllocationIgnoredInspection
-  extends BaseInspection {
+public class ResultOfObjectAllocationIgnoredInspection extends BaseInspection {
 
   @NotNull
   public String getDisplayName() {
-    return InspectionGadgetsBundle.message(
-      "result.of.object.allocation.ignored.display.name");
+    return InspectionGadgetsBundle.message("result.of.object.allocation.ignored.display.name");
   }
 
   @NotNull
   public String buildErrorString(Object... infos) {
-    return InspectionGadgetsBundle.message(
-      "result.of.object.allocation.ignored.problem.descriptor");
+    return InspectionGadgetsBundle.message("result.of.object.allocation.ignored.problem.descriptor");
   }
 
   public BaseInspectionVisitor buildVisitor() {
-    return new IgnoreResultOfCallVisitor();
+    return new ResultOfObjectAllocationIgnoredVisitor();
   }
 
-  private static class IgnoreResultOfCallVisitor
-    extends BaseInspectionVisitor {
+  private static class ResultOfObjectAllocationIgnoredVisitor extends BaseInspectionVisitor {
 
     @Override
-    public void visitExpressionStatement(
-      @NotNull PsiExpressionStatement statement) {
+    public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) {
       super.visitExpressionStatement(statement);
       final PsiExpression expression = statement.getExpression();
       if (!(expression instanceof PsiNewExpression)) {
         return;
       }
-      final PsiNewExpression newExpression =
-        (PsiNewExpression)expression;
-      final PsiExpression[] arrayDimensions =
-        newExpression.getArrayDimensions();
+      final PsiNewExpression newExpression = (PsiNewExpression)expression;
+      final PsiExpression[] arrayDimensions = newExpression.getArrayDimensions();
       if (arrayDimensions.length != 0) {
         return;
       }
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ResultOfObjectAllocationIgnored.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ResultOfObjectAllocationIgnored.html
index 077a8fb17157..a07bfe721c12 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/ResultOfObjectAllocationIgnored.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ResultOfObjectAllocationIgnored.html
@@ -1,6 +1,6 @@
 <html>
 <body>
-Reports object allocation where the object allocated ignored.
+Reports object allocations where the object allocated is ignored, and not assigned to a variable or used in another way.
 Such allocation expressions are legal Java, but are usually either inadvertent, or
 evidence of a very odd object initialization strategy.
 <!-- tooltip end -->
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ResultOfObjectAllocationIgnoredInspection.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/ResultOfObjectAllocationIgnored.java
similarity index 60%
rename from plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ResultOfObjectAllocationIgnoredInspection.java
rename to plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/ResultOfObjectAllocationIgnored.java
index 4f76d187ba20..1185f4ddb2ca 100644
--- a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/ResultOfObjectAllocationIgnoredInspection.java
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/ResultOfObjectAllocationIgnored.java
@@ -1,8 +1,8 @@
-package com.siyeh.igtest.bugs;
+package com.siyeh.igtest.bugs.result_of_object_allocation_ignored;
 
-public class ResultOfObjectAllocationIgnoredInspection {
+public class ResultOfObjectAllocationIgnored {
 
-    private ResultOfObjectAllocationIgnoredInspection() {
+    private ResultOfObjectAllocationIgnored() {
         super();
     }
 
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/expected.xml b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/expected.xml
new file mode 100644
index 000000000000..319a29ac85b1
--- /dev/null
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/bugs/result_of_object_allocation_ignored/expected.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problems>
+  <problem>
+    <file>ResultOfObjectAllocationIgnored.java</file>
+    <line>14</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Result of object allocation ignored</problem_class>
+    <description>Result of &lt;code&gt;new Comparable&lt;String&gt;()&lt;/code&gt; is ignored #loc</description>
+  </problem>
+
+  <problem>
+    <file>ResultOfObjectAllocationIgnored.java</file>
+    <line>10</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Result of object allocation ignored</problem_class>
+    <description>Result of &lt;code&gt;new Integer()&lt;/code&gt; is ignored #loc</description>
+  </problem>
+</problems>
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspectionTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspectionTest.java
new file mode 100644
index 000000000000..51e31a55987f
--- /dev/null
+++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/bugs/ResultOfObjectAllocationIgnoredInspectionTest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2000-2013 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.siyeh.ig.bugs;
+
+import com.siyeh.ig.IGInspectionTestCase;
+
+public class ResultOfObjectAllocationIgnoredInspectionTest extends IGInspectionTestCase {
+
+  public void test() throws Exception {
+    doTest("com/siyeh/igtest/bugs/result_of_object_allocation_ignored", new ResultOfObjectAllocationIgnoredInspection());
+  }
+}
\ No newline at end of file

From 75a5d52ba3cb79d3f7b385b024fcd3aab8e5ca00 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Wed, 27 Feb 2013 22:16:37 +0100
Subject: [PATCH 317/354] icons update

---
 platform/icons/src/actions/checked.png        | Bin 235 -> 287 bytes
 platform/icons/src/actions/checked@2x.png     | Bin 0 -> 449 bytes
 .../icons/src/actions/checked@2x_dark.png     | Bin 0 -> 449 bytes
 platform/icons/src/actions/checked_dark.png   | Bin 234 -> 291 bytes
 .../icons/src/actions/checked_selected.png    | Bin 234 -> 250 bytes
 .../icons/src/actions/checked_selected@2x.png | Bin 0 -> 391 bytes
 platform/icons/src/actions/checked_small.png  | Bin 135 -> 245 bytes
 .../icons/src/actions/checked_small@2x.png    | Bin 0 -> 380 bytes
 .../src/actions/checked_small@2x_dark.png     | Bin 0 -> 371 bytes
 .../icons/src/actions/checked_small_dark.png  | Bin 138 -> 245 bytes
 .../src/actions/checked_small_selected.png    | Bin 138 -> 224 bytes
 .../src/actions/checked_small_selected@2x.png | Bin 0 -> 326 bytes
 platform/icons/src/actions/menu-cut@2x.png    | Bin 0 -> 1524 bytes
 .../icons/src/actions/menu-cut@2x_dark.png    | Bin 1317 -> 1266 bytes
 platform/icons/src/actions/sortAsc.png        | Bin 351 -> 291 bytes
 platform/icons/src/actions/sortAsc@2x.png     | Bin 0 -> 493 bytes
 platform/icons/src/actions/sortDesc.png       | Bin 371 -> 281 bytes
 platform/icons/src/actions/sortDesc@2x.png    | Bin 0 -> 427 bytes
 18 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 platform/icons/src/actions/checked@2x.png
 create mode 100644 platform/icons/src/actions/checked@2x_dark.png
 create mode 100644 platform/icons/src/actions/checked_selected@2x.png
 create mode 100644 platform/icons/src/actions/checked_small@2x.png
 create mode 100644 platform/icons/src/actions/checked_small@2x_dark.png
 create mode 100644 platform/icons/src/actions/checked_small_selected@2x.png
 create mode 100644 platform/icons/src/actions/menu-cut@2x.png
 create mode 100644 platform/icons/src/actions/sortAsc@2x.png
 create mode 100644 platform/icons/src/actions/sortDesc@2x.png

diff --git a/platform/icons/src/actions/checked.png b/platform/icons/src/actions/checked.png
index 0cdacea486cb9ae5b9e4e01efde54ce526cb9d98..68ef20a3456c4decd8e82158140e2976da762959 100644
GIT binary patch
delta 222
zcmV<403rYD0iObpNq@mfL_t(|+G70w|33pMfDxo2Dk_SQx&R<vziinuMkXQ*<pbg=
zFb+%u$X#JLG_(V;G!U;w*6<sMrvtGRnqn&;&H&;UK%9xJp$>?JfOsy*Ur;eNAf5%~
zCj;?YWDQ+Fybp*yfH(~*RtCh{Ks*PCx52DrfztngI2MR60atMk5I+XuY9PJ`#6`$%
zL=L5AK%4}`+(5hqh*^O+4v4?t(f|URpq>Z0yBCO$q6ZlZmS8LaVgYDCV2^2106>5N
Y0JtzGUrpq*hX4Qo07*qoM6N<$f_CgxSpWb4

delta 170
zcmV;b09F5=0_y>gNq>z=L_t(|+G70w|33psfPe-@Aoc;`ERZ@7W+GtTG$7s##Hz&D
zPz;g=;^{!l1hWB`22LP83B(tGm>Fg;J`EvI)3uOYf~-Lwh-Uz?15|!H5N|^d9Aph3
zC*%R~9UzW?ny!XV0|@W{@dl{kOVA+2s{sULfcO;<Cu55*TqB-t0b&tc8W>4U8UO(X
Y0Cx0e(}{u`a{vGU07*qoM6N<$f`C{))Bpeg

diff --git a/platform/icons/src/actions/checked@2x.png b/platform/icons/src/actions/checked@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1481a0e824dbafcf287b8a80a96969292822175
GIT binary patch
literal 449
zcmV;y0Y3hTP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzV@X6oRCwBA`v3nw11&KV1C0R-j1e6j
zO)WFUfcVwYrAxsaYWtuGh+l%-3lpHG1%W_Z3uVVs+X4|Fo`%F1#$`bS5XX>V!DJwo
zK;oaph-9eY%c1NaK)i;8pou^eTZYXC@ks2cKrBjR(9A#+TL;7kuvzd0EvZc-GHAq*
z_)ma16<GnY1@q7}hd?nd5P}voe}Om-h~MF|U^@^mK{I43nhTMGW-6LkHxTbfSBRd9
zvViywT2M{JVgb6vr-8U0n>W!d_zc96K>Q0&P=VNCXmJ;friTGvMmqz<H8@<1EokzA
z_%^}94h{4Gu`>|6V+ktcpjnM2aS&y}e`vnA2*lz@L4yn)0dYE^bd0YodI`1UKNdMy
zl6+5z1t72!8eHh06NnEIQ;rZ*n$|!g9tKVVaRafXATbvFf+pS1Pz)+<f0JBg5&(Cg
rnUEPRBN7CRpqihSfaa|VfB*vk0UV6H^2rwj00000NkvXXu0mjfDkZBm

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/checked@2x_dark.png b/platform/icons/src/actions/checked@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..99aaa1d20a32ed1c3736056e4294a1eef1898747
GIT binary patch
literal 449
zcmV;y0Y3hTP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzV@X6oRCwBA`v3nw11&KV1C0R-jB)qw
zU22&r2E?zFm6gF9YWtuGh+hJ6G)#b+76bxuEtDNkZ3{$zcp4I47?%YRKpaDc1(ShT
z0*QYXBa)$pFNd;!0Pz|Uf+hk@Y#BBm#3Qk%0<kEOK{EqQY#k6Ez-GZ0w4^qT$e<BJ
z;y(f6RAdFn7R*D_90J9-KnPmU`~~7TAby9-g6%-O1kI4CXf8w!nyF}F-9Wq_T_JiZ
z$^zm$XhAg<iv{Qwp9bQ3Y~Dn-;4=_M0`V_AK?P!mp~YP^njQvx8SM-Z*Whq5wxG!e
z;@boZJ2cP(#LhtMjwPs&gJw0B#6gq=|DpNfA`pus1r0KI1jOlt(lNfW=q1#W|5)T;
zN%B1<7J$G`XmFu}P9Q!=OgTbKX<7q~co;Yd#0|ujg2Y(x3z~F4Loukd{Y`R}NdVk|
rW<qAPj7ShLf@*$R0-Cof00ImEdi;#Mk>VMF00000NkvXXu0mjf#R;nK

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/checked_dark.png b/platform/icons/src/actions/checked_dark.png
index 59042e8c0308ff7d7ae958c6681567dc9c46312a..a99148ad40fc248acceb1762910991a1ae7840e7 100644
GIT binary patch
delta 226
zcmV<803HA80iyztNq@yjL_t(|+G70w|33pMfDxqO?%lhD)CB<XdSzv0MkXQ*<pbg=
zFb+%u$X#JLG_(V;G!U;wcG52(`!f*h0`W5>#a2Lk7>Hj1u@2BlZ(%mn0kIGe&jlF*
z6=MV9Sx|m55WhusQWp^K17Z&#PJ@b-0kJj^&jI3X*g{DPh+8iKF*^{41Mym@^YnrE
z3rGRbNesxL1d>bwVs0Sb0>rF990ya39!fB<35cgd-Q5esN6~|f1xqlN0I>ixAh5?Y
cDF7hA0FBl(Pe6{6{{R3007*qoM6N<$f;>G}S^xk5

delta 169
zcmV;a09OB_0_p*fNq>w<L_t(|+G70w|33pMfQf)SBM|!laTc)}rUCJ0AXbHofSiN_
z7ypNV=|Ic`6KBNX2TmY90L1J-Yz)MI3E2<=HC+o`4#v<2;u%2f0OfB7;%(RrgE2UP
zI1h;L0C5D=bTxb$K$r)JH$W9%0%Ar&8bDYEh+hG5GOp0WCL-7Z#3HyfFp`=y00ImE
XEsYhD!{*FX00000NkvXXu0mjfqRv1d

diff --git a/platform/icons/src/actions/checked_selected.png b/platform/icons/src/actions/checked_selected.png
index 59042e8c0308ff7d7ae958c6681567dc9c46312a..a81060ee53e13b4ce92f7669b175f219f6c80d0c 100644
GIT binary patch
delta 185
zcmV;q07n1n0r~-uNq?M4L_t(|+G70w|33pMfQd+T0YD5f8Ds+i%m>6z{zCv<0|<oS
z&@dG$zY1ByFCcyk#8POAt$_G15I+ZEVPp*zP*b)8F(Xur4T!G*@joE;f*AtSzy!p5
zp_<a6Vl`0yEM!}etp_>h4G@2Zn)n@v?*cIoE)5{;2Xz7n|1tq$YxF?C7b>0DLJgY+
nP9R<i#O&BKFp`=y00ImEoUdlk(>B3v00000NkvXXu0mjfSrtbA

delta 169
zcmV;a09OC{0qOyeNq>w<L_t(|+G70w|33pMfQf)SBM|!laTc)}rUCJ0AXbHofSiN_
z7ypNV=|Ic`6KBNX2TmY90L1J-Yz)MI3E2<=HC+o`4#v<2;u%2f0OfB7;%(RrgE2UP
zI1h;L0C5D=bTxb$K$r)JH$W9%0%Ar&8bDYEh+hG5GOp0WCL-7Z#3HyfFp`=y00ImE
XEsYhD!{*FX00000NkvXXu0mjf+m%3e

diff --git a/platform/icons/src/actions/checked_selected@2x.png b/platform/icons/src/actions/checked_selected@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..8c2d7580e79ded073b184f4c68a8dc26ce471836
GIT binary patch
literal 391
zcmV;20eJq2P)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzDM>^@RCwBA{Qv(y11$j)1C0SKED)om
z1x-Nw5{RSWBA_^+5)S;20J~t~)bfD{5Klwm3*!o+2q2Cj!-B~`EP=#7i!F#Ekh~Z|
zX3)TZ156%S;dUeiFM(K;2*X97YLUTOWHrc&SEDIhO@sx@(eyk9Vj)}>cw+G?zMu+0
zQ~L*q9nsaHYg&w^3FLh-B7>$Kn?ukAc!Bsf5ka*QP0cAFW+TP|5H<ngpLl`_J!n1y
zu_~^h#1+1!ID!gW&?MnY2)HB|fp`a&ph8b+s|ckue3Ifo{Ng`u@DPXvDX{>A-GTTY
z7Q;bF(w>-{PE1kIg~ftaVv7=D6oHc8X(Yo>05K~yEdXH^ApQi!Dx}mCEJPN^cYrtx
lh?${mq5<QOZ&d&U7ywfut8asp6L|mt002ovPDHLkV1lial8pcW

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/checked_small.png b/platform/icons/src/actions/checked_small.png
index 366b1b532cd6ab984f9591ed3172ee1bb4659abc..fdf62ea2715d6147158a6cdf15d095552e1b97f0 100644
GIT binary patch
delta 217
zcmV;~04D#30rdfpB!3xnMObuGZ)S9NVRB^vL1b@YWgtmyVP|DhWnpA_ami&o0001&
zNkl<Zc-mt8|NlP&v4Dwz1i%7gL`6m6Qd0=Tean_DV?;JN4Tx3I6lwr*D-eH1cg9R0
zUJt}vP(CvdF92drsOcz*mjSUh$Vw=`6o}1%cry^sMR79_WKsgLB@m|r@lznK2I4nR
z=V64#Cy+mZ_zw^_0WmvN;|p9tcLIp(q3lIKybf#7A%RY4DCDC{Fp?63009O7#(N!{
T{s$F600000NkvXXu0mjf2+>fq

delta 106
zcmV-w0G0ps0fzyQBx6oVL_t(|+GAiCC=d+9cYrvYkV0u7ehI{V#F*L!#M_B=!ebyd
zz$GaHRgeY5kwCnQkZB=6{2que6XPimm;%JFftZsR#r#0rOL3qB0O5QLZs&4qKL7v#
M07*qoM6N<$g83{eh5!Hn

diff --git a/platform/icons/src/actions/checked_small@2x.png b/platform/icons/src/actions/checked_small@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..218c63e1b1cc5b3514b3e3875b5bae4ebe1669bf
GIT binary patch
literal 380
zcmV-?0fYXDP)<h;3K|Lk000e1NJLTq000&M000&U1^@s6#I$TX0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz9!W$&RCwBA{Qv(y11$jKsKGc5j*5yR
z)r>A6&H&;$%a$!Gf(bHF=&(Q_E(Ky<AWlM-z-2Hi5rzr@@iZj<J3<Dx0r3wYo=m{t
zDL^cN#9u_n;6kW)4iNj{34%x@{spLm@EUvzi9H*L#nI$N(1HNuyI3IpMabYzB(@k3
z&q9-*j1~mdKzs$=5Nrl71LD<4d{A&CBLzVOlH7hEo`5Z^aHR@Rx_pMj?+0QtAfACF
z_7R8^f%qRO2ET)9g5@4iIz0jn8W_j};)l4B489Dq3y7!UNZV`ClNTulgFrbD-#`<4
z0mSKqat|SczX5R^5dVhq|3f44Eu{v7z-b_EhO$9PZyPa%2n&&g4JcQs0detY4MH*i
a2rvL!GD$clnT9F=0000<MNUMnLSTXm0*kr;

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/checked_small@2x_dark.png b/platform/icons/src/actions/checked_small@2x_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..2c007efa8d285274c4859d93ce103b39606852fd
GIT binary patch
literal 371
zcmV-(0gV2MP)<h;3K|Lk000e1NJLTq000&M000&U1^@s6#I$TX0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUz6-h)vRCwBA{Qv(y11$g(1C7AYGnfTk
z;O^bKq?*wM#2G+5M_F09h*~ZV1maR4<^|#;VuFH|2t$Q{cp4J_9U+6;fcOUxPbOgS
z6d;yB;x8g(a3NGY2Z;Uf1VJPc{{qxOcn!XV#GVbr;%M?BXh8t-T`Um)B4ltU5?c(2
zXQ9bYMhk*!AihFOI$j3EtC9Gi;7CRaf(RtJ{Xjf{lneq&m(P&+{XlF6#50h@J_2zf
z5dR~^;CE0>uo4QCPLDu?1_ttg_#ru2dKVB+#gVqxq9-p>%ZhR!zJVt80*KQoErh-S
zaU2l;hVuVIBl0aZO1INM+ze%dlHNA5N;ez;l&jQ$xR}_|iE*@Qf&qX40|3}&H&Wz^
RjJ^N>002ovPDHLkV1ktUkZ=G1

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/checked_small_dark.png b/platform/icons/src/actions/checked_small_dark.png
index 7911a95b4192d5fbccfb0fe0eb375b7007778b50..4ddb2ec8b0952934d1e64b28098b0240b564d3a6 100644
GIT binary patch
delta 217
zcmV;~04D#60rdfpB!3xnMObuGZ)S9NVRB^vL1b@YWgtmyVP|DhWnpA_ami&o0001&
zNkl<Zc-mt8|NlP&v4Dwz1i%7g+`W4jmzqK#?o(D)W<)kQ4Tx3I6lwr*D-eH1cg9R0
zUJt}vP(CvdF92drsOcz*mjSUh$Vw=`6o}1%cry^sMR79_WKsgLB@m|r@lznK2I4nR
z=V64#Cm@aj;y*y#1jOu6jW2Ko-3cJBhq4y|@j9$QhXgvIp^%R*!AMFB0t6TU_nRG@
TjnW#$00000NkvXXu0mjfkk(S-

delta 109
zcmV-z0FwXp0g3^TBxX@bL_t(|+GAiC5b*#1|6m}#1H|Ek6iNf}OCate#?&?--cGC&
z9s{ufE=dunf-E481mazUObY?x_dtA^pr@c3rU3D4Am$`SF+ULZQXK98@6}W$ybZcq
P00000NkvXXu0mjf<OVED

diff --git a/platform/icons/src/actions/checked_small_selected.png b/platform/icons/src/actions/checked_small_selected.png
index 7911a95b4192d5fbccfb0fe0eb375b7007778b50..c5d048b2c312e662194a624f4864653edf50ec00 100644
GIT binary patch
delta 196
zcmV;#06YJR0pJ0UB!3xnMObuGZ)S9NVRB^vL1b@YWgtmyVP|DhWnpA_ami&o0001j
zNkl<Zc-mt8|NlP&v4Dwz1VD`9LLi1%4{`<+rvb4l5+8&$fcP5_e*!xfNdg3}05KPo
z&kV#TpyJ8sikCtqW<dEBQ2r*E8f3+MKzt9XpcaUK0P$-emOa3x7=$f=`1gMV2tt-e
yR}8{cP=yQ8<*+FRd2A673!uv}k`jXe0R{l576Vwj0Q=qm0000<MNUMnLSTZN|4D%W

delta 109
zcmV-z0FwXU0g3^TBxX@bL_t(|+GAiC5b*#1|6m}#1H|Ek6iNf}OCate#?&?--cGC&
z9s{ufE=dunf-E481mazUObY?x_dtA^pr@c3rU3D4Am$`SF+ULZQXK98@6}W$ybZcq
P00000NkvXXu0mjf+Z8M}

diff --git a/platform/icons/src/actions/checked_small_selected@2x.png b/platform/icons/src/actions/checked_small_selected@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..0e0838d93c2fc4a8bf26a5cf87b07a80f8e5d5fc
GIT binary patch
literal 326
zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1|*Mc$*~4fk|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*D5XUU<4VhE&{2`t$$4J+m&u;}r)B7>s5(-C;d4zhMV|<eVU9
z=KsnE*pqnDR1XCxD%AC*e6V$5+s^ngUSXckfd{Go109(aoA)bgep6QBaCl%NuvyUP
zhtj0B=?*%5YWhuLEDG%}7R+uw`#{6wdXCHF_&&Axmb2kI4&{r^dX^&NxPiZ8riY<~
z$YcMBJPb>NjWaGNsOwk8OzhUbcDLb&{3OTy7h<H_^{)zet)BcpnLV3hX|WSqG2_Ql
z6K6+Frx`)bjyFU!B^(?dyZV%=Z}VBvDrM7rqo^gKd1hmUp+K>4_J<5!CUyo!HU_Ch
W_Szep1vP<wX7F_Nb6Mw<&;$UMp>`Ai

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/menu-cut@2x.png b/platform/icons/src/actions/menu-cut@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..898293bc84a8767835877a1612dcd356f02acd9c
GIT binary patch
literal 1524
zcmV<Q1q=F#P)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F80000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU%mPtfGRCwCNR%=WgRTRGS-UrJoRV%3m
zt%)%<P1~p;#vi6eo0ecB@zGQh(FTD)frbzXp*Cv8lnUayE!ak*v0`o1KlKNi#$Wv*
zZLCF&qG@Qg62zhucA43or{9^Kh2>QisPS&T%$;-3ch0%zoO^dT$8p&IImFq5%F4=9
zcsvB`=<e?R<a#)P%}4O)1<nEY!tT_r`Ps@G$F%_Tj8s)s-MCWcu#p2>?{dk}lJ0!o
z0J^%mzJcNwz$&0?r2)W3JFo^g4coo5*ZBoVdjSV1t*)-#v0UfiZiS8Ky^OZZ>uaGV
ztf{G?`acPb0_!4?$jDNhgP()PkH8w>EAY3>r^hd3fam#rfCa1qmRt&O-UQYF4)D@~
zdJ8Rt!{Gs>?U<Lo$Li|pGA;#lDfQ2J+>@}?x8wl4UU(VMJwu1;>+4r9<{UbC&^_XD
zZ0e_LX6jmtot>Q*k-ql;N@+fDID^!8c&VrP3E234*#UT2*biu_QZzI)JiU-E*0w>X
z%+oc2eTxRXm_mDd`w%suw<AKhv9WPZDIm+k+R-$<55fI)#Q}I(H~>Vwo#g}F^XPN{
z1)dJ|%_|w5mQ0k|+S>l2ou}<?ds9=>GpTjVOCT#tTR#fUrHnS0>Azufb8{{pgFv1q
z`UkihNO%`cfhX61wXLnK!`CeXG+^*5()tFa*tTsJi^cNC#>OrKBbXPEEcGXrsq-ZT
z;2p6rGWItdGRv~)T?8bWlMHJyytggs&ni`dNbTnt5eCK6{cyNm6va{CVen0iQ;^*x
z2*N-|N5@?&`XI?53x(8ZvMd)D#O^syvZ3JF2Mxpc8Pi)<{6&Nz1LXi+IP1JJQIqwk
z!I2MSPF7r^C{A@R=5*!KRC;}Hdv0j_wx=+sQ?ecq01ECnaJVL1s?A%1@b1s(QNZJ4
z1eM(=3IcZP8b#ANsJYE_N7ctegR;fx)NEG(`qZ*v<4a(*;7BYdcDpXIfIJ`HGOYo)
zE8hKf>EPS|YCe^Df$vikaf2_QFvTY^GD5>dlO^H?i>o?Qtr&~u4ia;AJF(DMA@lPg
z=1=j(B%hoo;yTm7*AvDCyl<?HJRX}}f(no}gtGn2=U130&D?=3OH6`{O)#cw`OFMm
zr7Xm;j6FDhaWb0)glv`tJ_V4@cfgkv5i*g*Ce%ArHL(ZcS7#hUNfvenvlQkJCdnvi
zFANs|H)DR1WV9B{@-e^V-bKgdOND+QfO)rK<gx(xfocBN;NA+{faLU0HvB=E1w%e;
zM%+2)9#9l%ldMS4#YKaZBUKgJWPBL-6Z2gpqcxO>`Gp{TFTOyRk9Ps>3GhKvAwFGH
zNVx%ian1dgfl=@)!8g%gjC{bxoo`j2kY)rRxKSr>IbAndbV6gJS0-FUCsdncsoPGH
zM8p5b+9;KVfd7KHBue8PpX3|5!J^UWW}g^Wu_4p#1v)HL3h&fR_W*Wx4z((>90U+I
zsaD;SQLO^4W?QD+MGeXMIOg`O!~NuVot<_=^h36p_=yDZwRaAd_v}ImqQRgq48BNC
zy`KN2Hu8iqBLGC+0~DpQfU~s~_}y(HCz)yj8NmBTBqOBpKL$2W@iDg@`y!n(oA}N&
zpM1^f0bMta7>3oKN)y$Sy4gLFitMJ0)^P3qfOH-*O$+aiizMHCAN+5V{A8{DI86k_
zH-moxx}9?Zh---i8mAcP{*K;#Fc8WPux!BRlalAzwBg(+fv#p4CXScw!ac(Wx0~RX
zK<5lYOg=bG@`LW2DvstHFcRjL@&k`X=LDc>38rfCA;UC^kotN~;LhS`P7*Lb16du`
z?o-wHZ_s0giKg^^sZsV?@i25AK)NeAp7ntnlN3Sa1@1ifFXI1V)3f`x4KC}0<i8sK
a3NQfhH|zapEn4aT0000<MNUMnLSTYX*5#T2

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/menu-cut@2x_dark.png b/platform/icons/src/actions/menu-cut@2x_dark.png
index dc4a589f84249899a2cf5b15404fb5b2386a0250..2a2659801b316eae95eb83b3f1eb2029655c4371 100644
GIT binary patch
delta 1209
zcmV;q1V;O%3i1h%Nq>|{L_t(|+Qe5&Xk29!KKDI$GD#5Q(3*u2+*m|{3-Ph>fg8t_
zoh~YhT?A?+W)lJdGgg^YVgnXp+G<hSYHJs!uG)YI6*rYG6qB~-qSB&H(>5yUP3}DI
z)9>8eDK~c>nRJ5w@Nv(7{_~x4{`0?P1mE}R|7>zxk<aJP;eYciup^ht&7j{_0Qg{^
zS%_Z&-=Y6pbX<s6V0?W1Nqo)&w}3~0#Wp9|16&5uz|&)6W9OrTV%!=AKL~;_3#5TV
z0JVw3p|9C^@VW^EWf6oizz4D+?lyRp&%SbXV>Q}@6B83N_-t=uDWau6Jvus?t!E@Q
zVk6^s0I!XusDGB8ee7)*r`a)_oSggupI5`~4q&Fm*;jWxw-X~HBd;|w6q|VwMe$w0
z0a!i=q(iwGdO}+Yx$iZN(QI&dc=$Jz?`T+3F6Y4wl%D0I@Nwm?69}u22P)x=vLPDH
zK03~v@pb*TkiZ|nkw}n6OL1SM^b~S_-;4wp`+#C7r+;ICsyGx$jBVd%d9xC@2~0OA
zb-g~@-q_3p7#{#eou!DEo^AG5`x|}@>m?Aje}DtPUdM50Wo0F8SylmkU(+-tl}eE$
zNfg@r-RgC@Zi?(Qf)8<V-9{r$0?EmMV%s*c4s8iG2cn#|D^QxdC)zcvzH8TIS?*R8
z<tFd~5`U7Az_&=K$285W%GC#MxAlW$U4kq>2#~Jp&r~kn`z!18ZMQO5jtdaCw*8A}
zdgyBvpErP=;Va1P5^zfIs~opgRjw{gBq=|9z*2HwrMq-Zd%enszdL;3<H4zyt%i@$
z)LW-}ML{?t$x^>0@h%nuz32Jlx*m~YTZxBEm49T9gYnUP9()b>2IwJ2qVkobMYf{W
z<GYUgv*-IS4Slq|P?Nya;EXCt;stEz{zOtGEuoMc&eCyRs+4Ui7cIoFsB>GHg!uM_
z8{@J@va3-uex+j1d#?BR&~&yEUxM8r^>=pZl+fWwk=D#WRTWa8TQ-R7MVFGjK3Ad4
zp?}fzVnIM*H0tbb&L@K&Et!?wJm)pX5Jh{XBc+kvu}a2cHVeo116x^U9gne%vlQh0
z`Jd-J9Y{hx&bn6lh_$ok9zf|IQ#FO~h?0krSrvOAGx*d($t>SsnRPtIHj<<ISpPkq
z=Me+)o2-lT!Ciol8a~IWNk9s+76ONs<$s{mr9l7JqQSDyIv!&iY|_&8@BJc|mccS~
zPMptNZc)C-d_}Tq5<qr8`Mg^lI4I+)HHx234xHR#ESbHKKVuz_u?=kJeH@BlXS=Km
z_&>(^%S+~#{R1c0@V!<3rJ8#H*?kE-QJn?wB96>LICckoYVbYf`7C>@2f+6>%zv+`
zfMwZ7Y}=jV8NmmRk&5G_1z?$VJO-P2*nZ+TF8Y1|8}bJD7nxu8B0Bc=*<M9e&R|ac
zIIB3nt231OQjs`UVa~SfjA59CmE{sSwj17r5~Xl_ySh4B;_up*DKz|9ek^wux0tjC
z8S~HaheP!*FgxM8?%|?Yww8?|l`_i~Rk>XD1ZLUUm84`xqA7n@K4Z1~zu>=U{|Ybw
X)}qAu9)w9~00000NkvXXu0mjfNrqYS

delta 1260
zcmV<I1QYx638e~<Nq@&lL_t(|+QgSzXdOiu$G^RAE~hc358{Il=D{F^;)`uW$a@+e
z3|{bpl2U|15<)^sOioI3tHrch(+Gmt2E?Mps1=J3Vnxsgk)i?d_K*g8iPS?bJ(oRu
znO*<0*;DrHxwz>GI`Ct6XXl&wzW;nPvnzO>N8vIxHT51Y2Y<nl@$vE5ppI%R`@r{L
z89a=Box%$-+ENgNDPV!g>FMdVpsp5lumB`*EIfEw2a?I;3L3r}7@nP(nUQLAU;?y(
zU%-da@x*d^q2Y00fOarg!{GbCP;h^AY;4Sp<-q9Z=uJ@+-v$IGL0fRY9dxh&Bya_M
zR&Fe@Qr5uZ*MC8}FcrZZ-i`G9J~=Wn;*}jIx(dQ&c6OGhe=>MH!mDCt{eJKrka+eF
z4-Y?Hsi9b{7sz%BtZ#EFxb)`&>G|_m)iJ8Q92y$hfP5!I%PG!Ogr)xqe0$dp1S-sd
zTR}AKV6aN``@vA?d7NKsa$sO!AcIa$ggUJ>6;bIw2Y)}*>_DKxJK#oWptGTY3QU9?
z^T5%<yPa^r0Mntt+9Og&rN01{cG3X~qP|)t;;8ft91E*ct;lg5K(W9?DwSGbjPYk3
z{1$E7($ey&EX%*gJtku*AW2ez58#X)dM?4X?bFe^niVjXnhUp%{J{DqcF*0-&CN^b
zyc>0E;D3#^wY47Cb;+`<YoYc#qd>T*s+!X@&Hqlx{?xP#HlWI3)G=Nkyo+5*6qxV-
zggf;D=mC%LF~Of;QBJUVLDLfa{0K|Smz|<0{<$Iv@;xR|N7x>H`u5;-?_77L;$bw`
zx7dWO^P(h)9g>Xs69vECMH}Y0<VnoZTQjPlF@Hj${fxFx;&qxIQjX*FxcJsFmm6%)
zP?U1^jJYeG>mBGj)BS5%2j=@1FR7Z+sn@Hd>na98l<0#So2E_qoJqE8QDTotf?Rrv
zX8uq~Ff^)WZ|3craAa@){8Oo-DVXd1xJ$27I~#Y^QGJ6(vLZv;tq9;XshUiPi!!$b
zGJjWHN<3KXfVn34ga4a7KD6%7W%IA{v#ux!C0Ts2zEQhljKl0lsM89X5yd$f#&w9S
zA)%AIDHG~11Nr)8m#a8o{w+{kdpPra$tpnQUQJVcuU+PnZ8?JndLLT`8&=*v%pA7K
zk62YjB$7(G>tf%vuOTLu9+GfMu#{ZX-harN%ZRqbUelHP-s-)uyJ!k9UxL7mAs652
zV0=g3+nZUhp|Or+UqXR+f~~L6E#8)w8{fFB>0Wsi_N`(2Y&H-1T|};x*z;?V1E^TS
zTs_1S#<Fb6q>WQ2UpfD*%e*vXorO`8P8ydMiVA;`M=2gDcY)_I>aM`PHEf?r=YM>A
z$7Ut={b!yoPC`ieK6qy9-ow&yAI0*yimShjcp`DRc?Y<jFVtgr^6$54Uy=g{k9U0m
zPrt;h20NbOFD1x_Ia7Vfcn4^+YFW-}w$1!!#yoNyMwV%B%f9SRh_(70Hqwg_se>n!
zEQ!9nSRq@UV<WL`rz>xmDaUgBWM%UY2;Aol3yG}6vOjd<iB!eU@`dCj5%cvD3=ZLO
zPp}p9pURIA-J3?v%pfT#pSS#o3jdBg;>50cYHX~lYX9<NXD0T4!GBRi`k%``0t^8E
WB8{tl;YfG@0000<MNUMnLSTZEbbt2%

diff --git a/platform/icons/src/actions/sortAsc.png b/platform/icons/src/actions/sortAsc.png
index 176077a67f306f4035c0e822e0cbb55f8b6fc6fa..90a63224c8b3850e1cc65f42f4014cb25f24cf60 100644
GIT binary patch
delta 275
zcmV+u0qp+Y0;2+u8Gi-<001k^)wKWs02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM006~FL_t(|+G70w|33o^c(rb0WnyHQ_3uAJ>b7dHKQM771|-1D^uLUa
zl`#QG7bA-^!c1~$*r?9K$$Wu>jhW-eufN~FeE+Mzr@{X=+<zqNiZzT3|NqSf5*+{j
z|6>5soFG0}9H!{+zrPv(8UES+{`Z&R$L~K3zkoE5Zx0kt1zV?^vsi|cgXJnGCo>-l
z3&M$i{`_P3{{8RA??3)%v;1TDH}xOmKfYgo85w^6`v+G9aw<@qA1FVK5jhBO0e}Dl
Z0K!~c>H&|DISc>*002ovPDHLkV1ik-exU#W

delta 335
zcmV-V0kHm~0^b6V8Gi!+000~lC5He20Hsh&R7L;)|1(BnI#PEwS)m|9c{@>WKv;M_
zSA9HDZ5%>(L|~99NqIb7mOfQ>J5X#6K7v45g*#b_B}sb{JbOV{em_=sH&AydL1Zya
zdNNLXEK7GPLvK7(c{@^fI#G5oMP_G@)Uw$5meclz#`Jx{^nYNf{6TZhwcPoV()P34
z{-fRfiO&6m$o!1P`-H~+T$}%;)%-+)=17w9Z<^kUvgt~G=xDh6$099f0000WbW%=J
z008&-Pyhh(05$7O>i_^5-{TVv%>c~?si->9`S<zJms#2m0000<Nkl<Z2pt8%F%CdL
z006<=JLICchDbs}q7kM4KSZxmE2t1L6U|>Jll2q0i)yh=Xm)zT=3(P_nV(&|q^hTJ
hR@K#BcVG|z0Df!449}n%X!igB002ovPDHLkV1nJnlu-Zx

diff --git a/platform/icons/src/actions/sortAsc@2x.png b/platform/icons/src/actions/sortAsc@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..014886ce795d20d9b989af6d7340d9f30f01f0ec
GIT binary patch
literal 493
zcmV<J0TTX+P)<h;3K|Lk000e1NJLTq000sI000mO1^@s68wM|20000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzk4Z#9RCwB~RJ}?AK@i^A+cPnZl18wV
zG#28|1DL`>u=5Elk_V7j3Q@4KR0N6QJ6H&oK85d*?&9sv_|5%<B$tyEZunqs=KE&n
z+uI9?i2092+UWG|<1fxR5P<hO!sqpwaT*BM>_TSK5<P0nB45~ZT-VIzBwh+4xnGOT
zwnF1N-n3B&QUNS?ouyu@5g7&IK61y)xVkcHfy3gY%_y>?I5y;>JfU%t%1dD0!(+14
zS_nJ`oZ1i#I&nlsil4@sL+z%@FB*9~lwg*9OXf<25KZ%@XolJVoP$|SWg-w@L|&aE
zXQ2pqO)2sUjWwq=<$&ud6NL~mFo#QP<p_X~&5sXr(45wQLvRPBZpIpfEIYV2w^3#(
zx10KTls1$D?hu-eFWy>ykC>sBXB$zAkeRi#2(2jx+;wP1xpsOX<pRYMixbj4>zb5M
zj&h;tLfgx}f=>T!%f<G)*>vp&E}kCfDhr2gCX-;2#E*T-yG}?RFlL*wX(S`8x^yaN
jH^j>m{ny{fuK)u8Fy?gk(dl;^00000NkvXXu0mjf@k-jf

literal 0
HcmV?d00001

diff --git a/platform/icons/src/actions/sortDesc.png b/platform/icons/src/actions/sortDesc.png
index 8bc4b98958aba9bb63032060d1ccb8648809d6ba..63ee7ca4b47f37f70d389b1561ba2001fa87b009 100644
GIT binary patch
delta 265
zcmV+k0rvj$0+|Ak8Gi-<001k^)wKWs02y>eSaefwW^{L9a%BKPWN%_+AW3auXJt}l
zVPtu6$z?nM006s5L_t(|+G70w|33pEz~bMreIqk7qaPy{Ns#uxfB$b{VPR&-;^tto
zXJKaKM_2Uc@BdHVe*Dd5T3hP*^!J~?<^LJ}F)%Xzhhq>QD1TnDrquHZ3rNSi&p&7J
z{AGz^Wnr>ogj)0a&%YyIzWtd2l4pcD+_`?ODklf?B_<|Dj(`9D|M>pnufg8N;F};h
zCYb#|f!m+H{%ZL0{Wk-UZh<KP`wrQmpT7L+WnpE~{PX)?7qU1&fB^suMpoMuB2bwC
P0000<MNUMnLIPldU~PcK

delta 355
zcmbQq^qFabWIZzj1A~mPYCDkH7~m7)s_&d&?3QHWnPDA}V;z`p6PRlkT4o<s?hsJ{
zlmd!tIHu@1#S7U~t9n-R*)_>HmFswyYkF2HI9D3^RU7(N8GGe9M$~CJ=Nq`DIYhQv
z1l3!Fb-5%=unZ`%3M#h_DmMz6Vivj3DzMBZq_Td)y}vF^&s@4cc-6f~Soz1X_}r!&
zKR4a~xB2$JZIAx$y#KfD*q5%;UnU>^Kkf3jwby^7Zuynoe<gp`z3M%`Y7c#>U-jHe
zCg2Cq^{OR7e!)N*0vMUtIC+I7O|5(aR;)aG_Tt6+k6*w3^!@u!AYfkmsT8Qn$J50z
zB!)wl_25OW1_d703%l2`M12u*`TxJsu_Jgx?p)>X|5zKAtW0^SvF%sTX4&YCfu4Jn
wF33MkvHxk7D>C_^Z+oDD=Gu1d1|RtY{I#o8&YXRDQ4M6hr>mdKI;Vst01)_?+yDRo

diff --git a/platform/icons/src/actions/sortDesc@2x.png b/platform/icons/src/actions/sortDesc@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c30f322f1930560dc6826e8bf545806becf5ea3
GIT binary patch
literal 427
zcmV;c0aX5pP)<h;3K|Lk000e1NJLTq000sI000mO1^@s68wM|20000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzO-V#SRCwBA{Qv(y12q7PN6XgrKstaz
zb5^miGBahfFflqXGBOB|V*=1e@BaK_$YTU~EpGCzR2F8&S>zb>=kNcdMY(SCSs<n|
z%mEq{#l*<yK#C#%{{P?e`_KOcAT}c`uwy6fP+?_dy2Qx9z)6&s7#P0&{{2sHah}Ir
z5T6Mq0Tj6N^Y`C|-+%ux5QBkg>tTj~V-4AsuiyXlaj-Fm0|VX&e*iO_{qgH>Ke8Aj
zdOGs&++@hg!gLDV66Emx{pX+Q#&W+4$bwAhs(=d4|M>N%=hvUV4A?M84&4x}27$o$
zAAcKv{r-0wXfp#c28n^>u<5~S(B8)2AHcv&0S4-SqyYX86iWli5p56%>~9P?1k^Yi
zDVF8{#SY+7&x9{_e*XGf2K3TXAbt*Hm*Z2*NGSK4lrQrK#o(FFsI?RsL@WRZFaTlj
V>TYt6ryKwP002ovPDHLkV1jGn!2|#R

literal 0
HcmV?d00001


From e61ffd005b661073043569107aba635c7c6f7503 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Thu, 28 Feb 2013 01:24:03 +0100
Subject: [PATCH 318/354] don't call for default project

---
 .../src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java b/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java
index f7df9ebdf6b6..44b3b53b99f4 100644
--- a/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java
+++ b/platform/lang-impl/src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java
@@ -858,7 +858,7 @@ public abstract class ChooseByNameBase {
     myTextPopup.setLocation(bounds.getLocation());
 
     new MnemonicHelper().register(myTextFieldPanel);
-    if (myProject != null) {
+    if (myProject != null && !myProject.isDefault()) {
       DaemonCodeAnalyzer.getInstance(myProject).disableUpdateByTimer(myTextPopup);
     }
 

From de9b03a46deaef288ff70c805b4231bb5d7b5529 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Thu, 28 Feb 2013 11:35:47 +0400
Subject: [PATCH 319/354] Green code policy

---
 .../gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
index 4a4c3227e360..77d174e957ab 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/util/GradleUtil.java
@@ -229,6 +229,7 @@ public class GradleUtil {
       @Override
       public void set(@Nullable String error) {
         if (!StringUtil.isEmpty(error)) {
+          assert error != null;
           GradleLog.LOG.warn(error);
         }
       }

From dc3a4af0d1ddd062cfad517932294736966ed800 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Wed, 27 Feb 2013 18:39:16 +0400
Subject: [PATCH 320/354] cleanup

---
 .../psi/formatter/xml/AbstractXmlBlock.java   | 29 +++++++++----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/xml/impl/src/com/intellij/psi/formatter/xml/AbstractXmlBlock.java b/xml/impl/src/com/intellij/psi/formatter/xml/AbstractXmlBlock.java
index 4609f73e79fc..8b602e1b51a7 100644
--- a/xml/impl/src/com/intellij/psi/formatter/xml/AbstractXmlBlock.java
+++ b/xml/impl/src/com/intellij/psi/formatter/xml/AbstractXmlBlock.java
@@ -22,6 +22,7 @@ import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.codeStyle.CommonCodeStyleSettings;
 import com.intellij.psi.formatter.WhiteSpaceFormattingStrategy;
 import com.intellij.psi.formatter.WhiteSpaceFormattingStrategyFactory;
 import com.intellij.psi.formatter.common.AbstractBlock;
@@ -61,9 +62,6 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
                           final boolean preserveSpace) {
     super(node, wrap, alignment);
     myXmlFormattingPolicy = policy;
-    if (node == null) {
-      LOG.assertTrue(false);
-    }
     if (node.getTreeParent() == null) {
       myXmlFormattingPolicy.setRootBlock(node, this);
     }
@@ -105,9 +103,9 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
 
 
   public static WrapType getWrapType(final int type) {
-    if (type == CodeStyleSettings.DO_NOT_WRAP) return WrapType.NONE;
-    if (type == CodeStyleSettings.WRAP_ALWAYS) return WrapType.ALWAYS;
-    if (type == CodeStyleSettings.WRAP_AS_NEEDED) return WrapType.NORMAL;
+    if (type == CommonCodeStyleSettings.DO_NOT_WRAP) return WrapType.NONE;
+    if (type == CommonCodeStyleSettings.WRAP_ALWAYS) return WrapType.ALWAYS;
+    if (type == CommonCodeStyleSettings.WRAP_AS_NEEDED) return WrapType.NORMAL;
     return WrapType.CHOP_DOWN_IF_LONG;
   }
 
@@ -127,8 +125,8 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
     if (myNode.getElementType() == XmlElementType.XML_TEXT) return textWrap;
     final IElementType elementType = child.getElementType();
     if (elementType == XmlElementType.XML_ATTRIBUTE) return attrWrap;
-    if (elementType == XmlElementType.XML_START_TAG_START) return tagBeginWrap;
-    if (elementType == XmlElementType.XML_END_TAG_START) {
+    if (elementType == XmlTokenType.XML_START_TAG_START) return tagBeginWrap;
+    if (elementType == XmlTokenType.XML_END_TAG_START) {
       final PsiElement parent = SourceTreeToPsiMap.treeElementToPsi(child.getTreeParent());
       if (parent instanceof XmlTag) {
         final XmlTag tag = (XmlTag)parent;
@@ -138,7 +136,7 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
       }
       return null;
     }
-    if (elementType == XmlElementType.XML_TEXT || elementType == XmlElementType.XML_DATA_CHARACTERS) return textWrap;
+    if (elementType == XmlElementType.XML_TEXT || elementType == XmlTokenType.XML_DATA_CHARACTERS) return textWrap;
     return null;
   }
 
@@ -273,7 +271,7 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
                                          final Indent indent) {
     ASTNode resultNode = child;
     ASTNode currentChild = child.getTreeNext();
-    while (currentChild != null && currentChild.getElementType() != XmlElementType.XML_END_TAG_START) {
+    while (currentChild != null && currentChild.getElementType() != XmlTokenType.XML_END_TAG_START) {
       if (!containsWhiteSpacesOnly(currentChild)) {
         currentChild = processChild(result, currentChild, wrap, alignment, indent);
         resultNode = currentChild;
@@ -297,7 +295,8 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
         new XmlBlock(child, wrap, alignment, myXmlFormattingPolicy, indent, null, isPreserveSpace()) {
           protected Wrap getDefaultWrap(final ASTNode node) {
             final IElementType type = node.getElementType();
-            return type == XmlElementType.XML_ATTRIBUTE_VALUE_TOKEN ? Wrap.createWrap(getWrapType(myXmlFormattingPolicy.getAttributesWrap()), false) : null;
+            return type == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN
+                   ? Wrap.createWrap(getWrapType(myXmlFormattingPolicy.getAttributesWrap()), false) : null;
           }
         }
       );
@@ -415,8 +414,8 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
   public boolean isLeaf() {
     return (isComment(myNode)) ||
            myNode.getElementType() == TokenType.WHITE_SPACE ||
-           myNode.getElementType() == XmlElementType.XML_DATA_CHARACTERS ||
-           myNode.getElementType() == XmlElementType.XML_ATTRIBUTE_VALUE_TOKEN;
+           myNode.getElementType() == XmlTokenType.XML_DATA_CHARACTERS ||
+           myNode.getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN;
   }
 
   private static  boolean isComment(final ASTNode node) {
@@ -460,11 +459,11 @@ public abstract class AbstractXmlBlock extends AbstractBlock {
   }
 
   public boolean isCDATAStart() {
-    return myNode.getElementType() == XmlElementType.XML_CDATA_START;
+    return myNode.getElementType() == XmlTokenType.XML_CDATA_START;
   }
 
   public boolean isCDATAEnd() {
-    return myNode.getElementType() == XmlElementType.XML_CDATA_END;
+    return myNode.getElementType() == XmlTokenType.XML_CDATA_END;
   }
 
   public static boolean containsWhiteSpacesOnly(ASTNode node) {

From 42edec0783510583c34bb2adc7a73544248dfee2 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 11:43:29 +0400
Subject: [PATCH 321/354] IDEA-102009 Installing Color Plugin is not working,
 as there is a problem loading the SCALA plugin.  Also the settings dialog box
 cannot be opened

---
 .../src/com/intellij/openapi/options/ConfigurableEP.java       | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/platform/platform-api/src/com/intellij/openapi/options/ConfigurableEP.java b/platform/platform-api/src/com/intellij/openapi/options/ConfigurableEP.java
index 27aebd2efbf4..07430ddbad8b 100644
--- a/platform/platform-api/src/com/intellij/openapi/options/ConfigurableEP.java
+++ b/platform/platform-api/src/com/intellij/openapi/options/ConfigurableEP.java
@@ -149,6 +149,9 @@ public class ConfigurableEP<T extends UnnamedConfigurable> extends AbstractExten
     try {
       return myFactory.getValue().create();
     }
+    catch (LinkageError e) {
+      LOG.error(e);
+    }
     catch (Exception e) {
       LOG.error(e);
     }

From eaaa8cf642d87f424db8d7735022f9567a0de503 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 12:24:06 +0400
Subject: [PATCH 322/354] IDEA-101829 Spell Check does not check CDATA blocks

---
 spellchecker/spellchecker.iml                 |  1 +
 .../tokenizer/XmlTextTokenizer.java           | 23 +++++++++++--------
 .../inspection/xmlWithMistakes/test.xml       |  3 +++
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/spellchecker/spellchecker.iml b/spellchecker/spellchecker.iml
index ad0f6db77fe4..79b786a06bb7 100644
--- a/spellchecker/spellchecker.iml
+++ b/spellchecker/spellchecker.iml
@@ -15,6 +15,7 @@
     <orderEntry type="module" module-name="xml-openapi" />
     <orderEntry type="module" module-name="testFramework" scope="TEST" />
     <orderEntry type="module" module-name="dom-openapi" />
+    <orderEntry type="module" module-name="xml" />
   </component>
 </module>
 
diff --git a/spellchecker/src/com/intellij/spellchecker/tokenizer/XmlTextTokenizer.java b/spellchecker/src/com/intellij/spellchecker/tokenizer/XmlTextTokenizer.java
index 2703391ba897..44d032e9ecc3 100644
--- a/spellchecker/src/com/intellij/spellchecker/tokenizer/XmlTextTokenizer.java
+++ b/spellchecker/src/com/intellij/spellchecker/tokenizer/XmlTextTokenizer.java
@@ -15,28 +15,33 @@
  */
 package com.intellij.spellchecker.tokenizer;
 
-import com.intellij.lang.injection.InjectedLanguageManager;
-import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiLanguageInjectionHost;
+import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.xml.XmlElementType;
 import com.intellij.psi.xml.XmlText;
-import com.intellij.psi.xml.XmlToken;
 import com.intellij.psi.xml.XmlTokenType;
 import com.intellij.spellchecker.inspections.PlainTextSplitter;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
-
 public class XmlTextTokenizer extends Tokenizer<XmlText> {
   @Override
   public void tokenize(@NotNull XmlText element, TokenConsumer consumer) {
-    List<Pair<PsiElement,TextRange>> list = InjectedLanguageManager.getInstance(element.getProject()).getInjectedPsiFiles(element);
-    if (list != null && list.size() > 0) return;
+    if (element instanceof PsiLanguageInjectionHost && InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)element)) return;
+    processChildren(element, consumer);
+  }
+
+  private static void processChildren(PsiElement element, TokenConsumer consumer) {
     final PsiElement[] children = element.getChildren();
     for (PsiElement child : children) {
-      if (child instanceof XmlToken && ((XmlToken)child).getTokenType() == XmlTokenType.XML_DATA_CHARACTERS) {
+      IElementType elementType = child.getNode().getElementType();
+      if (elementType == XmlTokenType.XML_DATA_CHARACTERS) {
         consumer.consumeToken(child, PlainTextSplitter.getInstance());
       }
+      else if (elementType == XmlElementType.XML_CDATA) {
+        processChildren(child, consumer);
+      }
     }
   }
 }
diff --git a/spellchecker/testData/inspection/xmlWithMistakes/test.xml b/spellchecker/testData/inspection/xmlWithMistakes/test.xml
index 22db7e2a0308..3273389abcf6 100644
--- a/spellchecker/testData/inspection/xmlWithMistakes/test.xml
+++ b/spellchecker/testData/inspection/xmlWithMistakes/test.xml
@@ -2,5 +2,8 @@
  plain text <TYPO descr="Typo: In word 'gooes'">gooes</TYPO> here
 
 <b>&amp;</b>
+
+<description><![CDATA[ <TYPO descr="Typo: In word 'foozz'">foozz</TYPO> ]]></description>
+
 </a>
 

From 69cfa18d62fe235069c98ca1dad0257c5ee3d0d9 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 28 Feb 2013 09:34:43 +0100
Subject: [PATCH 323/354] Test data fixed

---
 .../throws_runtime_exception/MoveThrows.java      | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
index 08723c03b257..ea95fddcf155 100644
--- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
+++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/errorhandling/throws_runtime_exception/MoveThrows.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2000-2013 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.
- */
 class C {
   void foo() throws RuntimeException<caret> {}
 }
\ No newline at end of file

From f78fc6c451d337629541b43f7a228d81b6659ba3 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Thu, 28 Feb 2013 12:55:39 +0400
Subject: [PATCH 324/354] IDEA-95644 Support console input filtering

Expand InputFilter api in accordance with the comments at the ticket's end
---
 .../execution/filters/CompositeInputFilter.java        |  4 ++--
 .../com/intellij/execution/filters/InputFilter.java    |  6 ++++--
 .../com/intellij/execution/impl/ConsoleViewImpl.java   | 10 ++++++----
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/execution/filters/CompositeInputFilter.java b/platform/lang-api/src/com/intellij/execution/filters/CompositeInputFilter.java
index 7ba812f9e8d7..1801f74869dc 100644
--- a/platform/lang-api/src/com/intellij/execution/filters/CompositeInputFilter.java
+++ b/platform/lang-api/src/com/intellij/execution/filters/CompositeInputFilter.java
@@ -39,13 +39,13 @@ public class CompositeInputFilter implements InputFilter {
 
   @Override
   @Nullable
-  public Pair<String, ConsoleViewContentType> applyFilter(final String text, final ConsoleViewContentType contentType) {
+  public List<Pair<String, ConsoleViewContentType>> applyFilter(final String text, final ConsoleViewContentType contentType) {
     boolean dumb = myDumbService.isDumb();
     for (Pair<InputFilter, Boolean> pair : myFilters) {
       if (!dumb || pair.second == Boolean.TRUE) {
         long t0 = System.currentTimeMillis();
         InputFilter filter = pair.first;
-        Pair<String, ConsoleViewContentType> result = filter.applyFilter(text, contentType);
+        List<Pair<String, ConsoleViewContentType>> result = filter.applyFilter(text, contentType);
         t0 = System.currentTimeMillis() - t0;
         if (t0 > 100) {
           LOG.warn(filter.getClass().getSimpleName() + ".applyFilter() took " + t0 + " ms on '''" + text + "'''");
diff --git a/platform/lang-api/src/com/intellij/execution/filters/InputFilter.java b/platform/lang-api/src/com/intellij/execution/filters/InputFilter.java
index 648b1ee037c5..5110ef0a9654 100644
--- a/platform/lang-api/src/com/intellij/execution/filters/InputFilter.java
+++ b/platform/lang-api/src/com/intellij/execution/filters/InputFilter.java
@@ -19,14 +19,16 @@ import com.intellij.execution.ui.ConsoleViewContentType;
 import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
+
 public interface InputFilter {
 
   /**
    * @param text        the text to be filtered.
    * @param contentType the content type of filtered text
-   * @return            <tt>null</tt>, if there was no match, otherwise, a pair of ('string to use', 'content type to use')
+   * @return            <tt>null</tt>, if there was no match, otherwise, a list of pairs like ('string to use', 'content type to use')
    */
   @Nullable
-  Pair<String, ConsoleViewContentType> applyFilter(String text, ConsoleViewContentType contentType);
+  List<Pair<String, ConsoleViewContentType>> applyFilter(String text, ConsoleViewContentType contentType);
 
 }
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewImpl.java
index b8f23dedd73b..5ec07f90c479 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewImpl.java
@@ -531,18 +531,20 @@ public class ConsoleViewImpl extends JPanel implements ConsoleView, ObservableCo
       return;
     }
     
-    Pair<String, ConsoleViewContentType> result = myInputMessageFilter.applyFilter(s, contentType);
+    List<Pair<String, ConsoleViewContentType>> result = myInputMessageFilter.applyFilter(s, contentType);
     if (result == null) {
       printHyperlink(s, contentType, null);
     }
     else {
-      if (result.first != null) {
-        printHyperlink(result.first, result.second == null ? contentType : result.second, null);
+      for (Pair<String, ConsoleViewContentType> pair : result) {
+        if (pair.first != null) {
+          printHyperlink(pair.first, pair.second == null ? contentType : pair.second, null);
+        }
       }
     }
   }
 
-  private void printHyperlink(String s, ConsoleViewContentType contentType, HyperlinkInfo info) {
+  private void printHyperlink(String s, ConsoleViewContentType contentType, @Nullable HyperlinkInfo info) {
     synchronized (LOCK) {
       Pair<String, Integer> pair = myBuffer.print(s, contentType, info);
       s = pair.first;

From b858f83ff712ebde56b762a5a2487bf56957aa3e Mon Sep 17 00:00:00 2001
From: Dmitry Jemerov <yole@jetbrains.com>
Date: Thu, 28 Feb 2013 10:05:41 +0100
Subject: [PATCH 325/354] since jsch depends on jzlib, jzlib must live in the
 same place as jsch (WI-16737)

---
 build/scripts/libLicenses.gant |   1 +
 lib/jzlib-1.1.1.jar            | Bin 0 -> 69578 bytes
 lib/src/jzlib-1.1.1.zip        | Bin 0 -> 105191 bytes
 3 files changed, 1 insertion(+)
 create mode 100644 lib/jzlib-1.1.1.jar
 create mode 100644 lib/src/jzlib-1.1.1.zip

diff --git a/build/scripts/libLicenses.gant b/build/scripts/libLicenses.gant
index 853e8e76af1a..542b08d9936e 100644
--- a/build/scripts/libLicenses.gant
+++ b/build/scripts/libLicenses.gant
@@ -254,6 +254,7 @@ libraryLicense(name: "proxy-vole", libraryName: "proxy-vole", version: "20120920
 libraryLicense(name: "Rhino JavaScript Engine", libraryName: "rhino-js-1_7R4", version: "1.7R4", license: "MPL 1.1", url: "http://www.mozilla.org/rhino/", licenseUrl: "http://www.mozilla.org/MPL/MPL-1.1.html")
 libraryLicense(name: "asm-4.0-all", libraryName: "asm-4.0-all", version: "4.0", attachedTo: "ByteCodeViewer", license: "BSD", url: "http://asm.objectweb.org/", licenseUrl: "http://asm.objectweb.org/license.html")
 libraryLicense(name: "jsr305", libraryName: "jsr305", version: "snapshot", license: "BSD", url: "http://code.google.com/p/jsr-305/", licenseUrl: "http://code.google.com/p/jsr-305/source/browse/trunk/ri/LICENSE")
+libraryLicense(name: "jzlib", libraryName: "jzlib", version: "1.1.1", license: "BSD", url: "http://www.jcraft.com/jzlib/", licenseUrl: "http://www.jcraft.com/jzlib/LICENSE.txt")
 jetbrainsLibrary("JPS")
 jetbrainsLibrary("Maven Embedder")
 jetbrainsLibrary("tcServiceMessages")
diff --git a/lib/jzlib-1.1.1.jar b/lib/jzlib-1.1.1.jar
new file mode 100644
index 0000000000000000000000000000000000000000..5530c9d142c9a45d245d47841c950743888d8aae
GIT binary patch
literal 69578
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

literal 0
HcmV?d00001

diff --git a/lib/src/jzlib-1.1.1.zip b/lib/src/jzlib-1.1.1.zip
new file mode 100644
index 0000000000000000000000000000000000000000..c0745a092f3eb8767b7a605cd550d798b8b4a084
GIT binary patch
literal 105191
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

literal 0
HcmV?d00001


From 888c5cf6ed4f8b7a3e8478cae8f87a9a7eabf7c4 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 13:07:50 +0400
Subject: [PATCH 326/354] IDEA-100777 Tasks no longer Persist Context

---
 .../tasks/context/WorkingContextManager.java  | 31 ++++++++++++++++++-
 .../intellij/tasks/context/ContextTest.java   | 11 +++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
index c411c50eb19d..e9d4a07157f4 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
@@ -16,6 +16,9 @@
 
 package com.intellij.tasks.context;
 
+import com.intellij.notification.Notification;
+import com.intellij.notification.NotificationType;
+import com.intellij.notification.Notifications;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
@@ -36,6 +39,7 @@ import org.jdom.output.XMLOutputter;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
 import java.io.File;
 import java.io.IOException;
@@ -137,6 +141,27 @@ public class WorkingContextManager {
   }
 
   private JBZipFile getTasksArchive(String postfix) throws IOException {
+    File file = getArchiveFile(postfix);
+    try {
+      return new JBZipFile(file);
+    }
+    catch (IOException e) {
+      file.delete();
+      JBZipFile zipFile = null;
+      try {
+        zipFile = new JBZipFile(file);
+        Notifications.Bus.notify(new Notification("Tasks", "Context Data Corrupted",
+                                                  "Context information history for " + myProject.getName() + " was corrupted.\n" +
+                                                  "The history was replaced with empty one.", NotificationType.ERROR), myProject);
+      }
+      catch (IOException e1) {
+        LOG.error("Can't repair form context data corruption", e1);
+      }
+      return zipFile;
+    }
+  }
+
+  private File getArchiveFile(String postfix) {
     String configPath = PathManager.getConfigPath(true);
     File tasksFolder = new File(configPath, TASKS_FOLDER);
     if (!tasksFolder.exists()) {
@@ -144,7 +169,7 @@ public class WorkingContextManager {
       tasksFolder.mkdir();
     }
     String projectName = myProject.getName();
-    return new JBZipFile(new File(tasksFolder, projectName + postfix));
+    return new File(tasksFolder, projectName + postfix);
   }
 
   public void restoreContext(@NotNull Task task) {
@@ -237,6 +262,10 @@ public class WorkingContextManager {
     catch (IOException e) {
       LOG.error(e);
     }
+  }
 
+  @TestOnly
+  public File getContextFile() throws IOException {
+    return getArchiveFile(CONTEXT_ZIP_POSTFIX);
   }
 }
diff --git a/plugins/tasks/tasks-tests/test/com/intellij/tasks/context/ContextTest.java b/plugins/tasks/tasks-tests/test/com/intellij/tasks/context/ContextTest.java
index 9a56140acc28..d9471d75c047 100644
--- a/plugins/tasks/tasks-tests/test/com/intellij/tasks/context/ContextTest.java
+++ b/plugins/tasks/tasks-tests/test/com/intellij/tasks/context/ContextTest.java
@@ -16,8 +16,10 @@
 
 package com.intellij.tasks.context;
 
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.tasks.TaskManagerTestCase;
 
+import java.io.File;
 import java.util.List;
 
 /**
@@ -55,6 +57,15 @@ public class ContextTest extends TaskManagerTestCase {
     assertEquals("/context2", history.get(0).name);
   }
 
+  public void testContextFileRepair() throws Exception {
+    WorkingContextManager manager = getContextManager();
+    manager.saveContext("foo", "bar");
+    File file = manager.getContextFile();
+    assertTrue(file.length() > 0);
+    FileUtil.writeToFile(file, "123");   // corrupt it
+    manager.saveContext("foo", "bar");
+  }
+
   private WorkingContextManager getContextManager() {
     return WorkingContextManager.getInstance(getProject());
   }

From 196a08a74d5c974503e362576fffa49be3b5e254 Mon Sep 17 00:00:00 2001
From: "Denis.Zhdanov" <Denis.Zhdanov@jetbrains.com>
Date: Thu, 28 Feb 2013 13:10:14 +0400
Subject: [PATCH 327/354] IDEA-101921 Gradle: Throwable at
 ModuleOrderEntryImpl.setScope() on changing scope or "Exported" of module
 dependency during auto-import

Gradle dependency manager applies new dependency scope and 'exported' status for the up-to-date modifiable model now
---
 .../manage/GradleDependencyManager.java       | 37 ++++++++++++++++++-
 1 file changed, 35 insertions(+), 2 deletions(-)

diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
index 22c403502f88..3c52c398d16f 100644
--- a/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
+++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/manage/GradleDependencyManager.java
@@ -6,6 +6,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTable;
+import com.intellij.util.Consumer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.plugins.gradle.config.PlatformFacade;
 import org.jetbrains.plugins.gradle.model.gradle.*;
@@ -181,23 +182,55 @@ public class GradleDependencyManager {
     }
   }
 
+  @SuppressWarnings("MethodMayBeStatic")
   public void setScope(@NotNull final DependencyScope scope, @NotNull final ExportableOrderEntry dependency, boolean synchronous) {
     Project project = dependency.getOwnerModule().getProject();
     GradleUtil.executeProjectChangeAction(project, dependency, synchronous, new Runnable() {
       @Override
       public void run() {
-        dependency.setScope(scope); 
+        doForDependency(dependency, new Consumer<ExportableOrderEntry>() {
+          @Override
+          public void consume(ExportableOrderEntry entry) {
+            entry.setScope(scope);
+          }
+        });
       }
     });
   }
 
+  @SuppressWarnings("MethodMayBeStatic")
   public void setExported(final boolean exported, @NotNull final ExportableOrderEntry dependency, boolean synchronous) {
     Project project = dependency.getOwnerModule().getProject();
     GradleUtil.executeProjectChangeAction(project, dependency, synchronous, new Runnable() {
       @Override
       public void run() {
-        dependency.setExported(exported);
+        doForDependency(dependency, new Consumer<ExportableOrderEntry>() {
+          @Override
+          public void consume(ExportableOrderEntry entry) {
+            entry.setExported(exported);
+          }
+        });
       }
     });
   }
+
+  private static void doForDependency(@NotNull ExportableOrderEntry entry, @NotNull Consumer<ExportableOrderEntry> consumer) {
+    // We need to get an up-to-date modifiable model to work with.
+    ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(entry.getOwnerModule());
+    final ModifiableRootModel moduleRootModel = moduleRootManager.getModifiableModel();
+    try {
+      // The thing is that intellij created order entry objects every time new modifiable model is created,
+      // that's why we can't use target dependency object as is but need to get a reference to the current
+      // entry object from the model instead.
+      for (OrderEntry e : moduleRootModel.getOrderEntries()) {
+        if (e instanceof ExportableOrderEntry && e.getPresentableName().equals(entry.getPresentableName())) {
+          consumer.consume((ExportableOrderEntry)e);
+          break;
+        }
+      }
+    }
+    finally {
+      moduleRootModel.commit();
+    }
+  }
 }

From 62eb0fbdfc5b984366593030b645ede3d4d3caf8 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 13:17:12 +0400
Subject: [PATCH 328/354] IDEA-100777 Tasks no longer Persist Context:
 synchronizing access to data files

---
 .../com/intellij/tasks/context/WorkingContextManager.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
index e9d4a07157f4..f990aabc0eaf 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
@@ -116,7 +116,7 @@ public class WorkingContextManager {
     saveContext(entryName, CONTEXT_ZIP_POSTFIX, comment);
   }
 
-  private void saveContext(@Nullable String entryName, String zipPostfix, @Nullable String comment) {
+  private synchronized void saveContext(@Nullable String entryName, String zipPostfix, @Nullable String comment) {
     try {
       JBZipFile archive = getTasksArchive(zipPostfix);
       if (entryName == null) {
@@ -176,7 +176,7 @@ public class WorkingContextManager {
     loadContext(TASKS_ZIP_POSTFIX, task.getId() + TASK_XML_POSTFIX);
   }
 
-  private boolean loadContext(String zipPostfix, String entryName) {
+  private synchronized boolean loadContext(String zipPostfix, String entryName) {
     try {
       JBZipFile archive = getTasksArchive(zipPostfix);
       JBZipEntry entry = archive.getEntry(StringUtil.startsWithChar(entryName, '/') ? entryName : "/" + entryName);
@@ -199,7 +199,7 @@ public class WorkingContextManager {
     return getContextHistory(CONTEXT_ZIP_POSTFIX);
   }
 
-  private List<ContextInfo> getContextHistory(String zipPostfix) {
+  private synchronized List<ContextInfo> getContextHistory(String zipPostfix) {
     try {
       JBZipFile archive = getTasksArchive(zipPostfix);
       List<JBZipEntry> entries = archive.getEntries();
@@ -246,7 +246,7 @@ public class WorkingContextManager {
     pack(max, delta, TASKS_ZIP_POSTFIX);
   }
 
-  private void pack(int max, int delta, String zipPostfix) {
+  private synchronized void pack(int max, int delta, String zipPostfix) {
     try {
       JBZipFile archive = getTasksArchive(zipPostfix);
       List<JBZipEntry> entries = archive.getEntries();

From 7b76655283e8f09ef3052b9204244a23044bd3eb Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 13:21:22 +0400
Subject: [PATCH 329/354] IDEA-100777 Tasks no longer Persist Context: closing
 archives

---
 .../tasks/context/WorkingContextManager.java  | 38 +++++++++++++++----
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
index f990aabc0eaf..6e58c392c30c 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
@@ -177,31 +177,46 @@ public class WorkingContextManager {
   }
 
   private synchronized boolean loadContext(String zipPostfix, String entryName) {
+    JBZipFile archive = null;
     try {
-      JBZipFile archive = getTasksArchive(zipPostfix);
+      archive = getTasksArchive(zipPostfix);
       JBZipEntry entry = archive.getEntry(StringUtil.startsWithChar(entryName, '/') ? entryName : "/" + entryName);
       if (entry != null) {
         byte[] bytes = entry.getData();
         Document document = JDOMUtil.loadDocument(new String(bytes));
         Element rootElement = document.getRootElement();
         loadContext(rootElement);
-        archive.close();
         return true;
       }
     }
     catch (Exception e) {
       LOG.error(e);
     }
+    finally {
+      closeArchive(archive);
+    }
     return false;
   }
 
+  private static void closeArchive(JBZipFile archive) {
+    if (archive != null) {
+      try {
+        archive.close();
+      }
+      catch (IOException e) {
+        LOG.error(e);
+      }
+    }
+  }
+
   public List<ContextInfo> getContextHistory() {
     return getContextHistory(CONTEXT_ZIP_POSTFIX);
   }
 
   private synchronized List<ContextInfo> getContextHistory(String zipPostfix) {
+    JBZipFile archive = null;
     try {
-      JBZipFile archive = getTasksArchive(zipPostfix);
+      archive = getTasksArchive(zipPostfix);
       List<JBZipEntry> entries = archive.getEntries();
       return ContainerUtil.mapNotNull(entries, new NullableFunction<JBZipEntry, ContextInfo>() {
         public ContextInfo fun(JBZipEntry entry) {
@@ -213,6 +228,9 @@ public class WorkingContextManager {
       LOG.error(e);
       return Collections.emptyList();
     }
+    finally {
+      closeArchive(archive);
+    }
   }
 
   public boolean loadContext(String name) {
@@ -228,17 +246,20 @@ public class WorkingContextManager {
   }
 
   private void removeContext(String name, String postfix) {
+    JBZipFile archive = null;
     try {
-      JBZipFile archive = getTasksArchive(postfix);
+      archive = getTasksArchive(postfix);
       JBZipEntry entry = archive.getEntry(name);
       if (entry != null) {
         archive.eraseEntry(entry);
       }
-      archive.close();
     }
     catch (IOException e) {
       LOG.error(e);
     }
+    finally {
+      closeArchive(archive);
+    }
   }
 
   public void pack(int max, int delta) {
@@ -247,8 +268,9 @@ public class WorkingContextManager {
   }
 
   private synchronized void pack(int max, int delta, String zipPostfix) {
+    JBZipFile archive = null;
     try {
-      JBZipFile archive = getTasksArchive(zipPostfix);
+      archive = getTasksArchive(zipPostfix);
       List<JBZipEntry> entries = archive.getEntries();
       if (entries.size() > max + delta) {
         JBZipEntry[] array = entries.toArray(new JBZipEntry[entries.size()]);
@@ -257,11 +279,13 @@ public class WorkingContextManager {
           archive.eraseEntry(array[i]);
         }
       }
-      archive.close();
     }
     catch (IOException e) {
       LOG.error(e);
     }
+    finally {
+      closeArchive(archive);
+    }
   }
 
   @TestOnly

From a3f2540fa49a0e000f4242f3d8e9c24e32d05a5d Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 13:22:03 +0400
Subject: [PATCH 330/354] cleanup

---
 .../src/com/intellij/tasks/context/WorkingContextManager.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
index 6e58c392c30c..7e565db65aa2 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
@@ -132,7 +132,7 @@ public class WorkingContextManager {
       Element element = new Element("context");
       saveContext(element);
       String s = new XMLOutputter().outputString(element);
-      entry.setData(s.getBytes());
+      entry.setData(s.getBytes("UTF-8"));
       archive.close();
     }
     catch (IOException e) {

From 2334d487d36c849dedc371254429f72cfbe7137c Mon Sep 17 00:00:00 2001
From: Sergey Simonchik <sergey.simonchik@jetbrains.com>
Date: Thu, 28 Feb 2013 13:37:46 +0400
Subject: [PATCH 331/354] respect case-insensitive Windows nature

---
 .../PathEnvironmentVariableUtil.java          | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/execution/configurations/PathEnvironmentVariableUtil.java b/platform/platform-api/src/com/intellij/execution/configurations/PathEnvironmentVariableUtil.java
index f1e7bce7b87c..6bac7c646f88 100644
--- a/platform/platform-api/src/com/intellij/execution/configurations/PathEnvironmentVariableUtil.java
+++ b/platform/platform-api/src/com/intellij/execution/configurations/PathEnvironmentVariableUtil.java
@@ -5,6 +5,8 @@ import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.EnvironmentUtil;
 import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.text.CaseInsensitiveStringHashingStrategy;
+import gnu.trove.THashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -20,10 +22,20 @@ public class PathEnvironmentVariableUtil {
 
   public static final String PATH_ENV_VAR_NAME = "PATH";
 
-  private static final String ourFixedMacPathEnvVarValue;
+  private static final Map<String, String> ENVIRONMENT_VARIABLES;
+  private static final String FIXED_MAC_PATH_VALUE;
 
   static {
-    ourFixedMacPathEnvVarValue = calcFixedMacPathEnvVarValue();
+    Map<String, String> envVars = EnvironmentUtil.getEnvironmentProperties();
+    if (SystemInfo.isWindows) {
+      THashMap<String, String> map = new THashMap<String, String>(CaseInsensitiveStringHashingStrategy.INSTANCE);
+      map.putAll(envVars);
+      ENVIRONMENT_VARIABLES = map;
+    }
+    else {
+      ENVIRONMENT_VARIABLES = envVars;
+    }
+    FIXED_MAC_PATH_VALUE = calcFixedMacPathEnvVarValue();
   }
 
   private PathEnvironmentVariableUtil() {
@@ -35,7 +47,7 @@ public class PathEnvironmentVariableUtil {
    */
   @Nullable
   public static String getFixedPathEnvVarValueOnMac() {
-    return ourFixedMacPathEnvVarValue;
+    return FIXED_MAC_PATH_VALUE;
   }
 
   private static String calcFixedMacPathEnvVarValue() {
@@ -67,8 +79,7 @@ public class PathEnvironmentVariableUtil {
 
   @Nullable
   private static String getOriginalPathEnvVarValue() {
-    Map<String, String> originalEnvVars = EnvironmentUtil.getEnvironmentProperties();
-    return originalEnvVars.get(PATH_ENV_VAR_NAME);
+    return ENVIRONMENT_VARIABLES.get(PATH_ENV_VAR_NAME);
   }
 
   @NotNull

From 7536898a11d85547ef931811929b62eec4ad2c68 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 28 Feb 2013 10:53:39 +0100
Subject: [PATCH 332/354] Check for Mercurial before setting up test project

---
 .../testSrc/hg4idea/test/HgExecutor.java      | 20 ++-----------------
 .../testSrc/hg4idea/test/HgPlatformTest.java  |  8 +++-----
 2 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgExecutor.java b/plugins/hg4idea/testSrc/hg4idea/test/HgExecutor.java
index 99a90cbd8d78..35982698a670 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgExecutor.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/HgExecutor.java
@@ -29,29 +29,13 @@ public class HgExecutor extends Executor {
   private static final String HG_EXECUTABLE_ENV = "IDEA_TEST_HG_EXECUTABLE";
   //private static final String TEAMCITY_HG_EXECUTABLE_ENV = "TEAMCITY_HG_PATH";   //todo var for server testing
 
-  private static boolean myVersionPrinted;
-  private static final String HG_EXECUTABLE = findHgExecutable();
-
-  private static String findHgExecutable() {
-    return findExecutable("hg", "hg", "hg.exe", Arrays.asList(HG_EXECUTABLE_ENV));
-  }
+  private static final String HG_EXECUTABLE = findExecutable("hg", "hg", "hg.exe", Arrays.asList(HG_EXECUTABLE_ENV));
 
   public static String hg(String command) {
-    printVersionTheFirstTime();
     List<String> split = StringUtil.split(command, " ");
     split.add(0, HG_EXECUTABLE);
     log("hg " + command);
-    for(int attempt = 0; attempt < 3; attempt++) {
-      return run(split);
-    }
-    throw new RuntimeException("fatal error during execution of Hg command: " + command);
+    return run(split);
   }
 
-  private static void printVersionTheFirstTime() {
-    if (!myVersionPrinted) {
-      myVersionPrinted = true;
-      hg("version");
-    }
-  }
 }
-
diff --git a/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
index b63ba4cde670..60dff15e1a98 100644
--- a/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
+++ b/plugins/hg4idea/testSrc/hg4idea/test/HgPlatformTest.java
@@ -55,6 +55,9 @@ public abstract class HgPlatformTest extends LightPlatformTestCase {
 
   @Override
   protected void setUp() throws Exception {
+    cd(FileUtil.getTempDirectory());
+    hg("version");
+
     super.setUp();
 
     myProject = getProject();
@@ -65,11 +68,6 @@ public abstract class HgPlatformTest extends LightPlatformTestCase {
     setUpHgrc(myRepository);
   }
 
-  @Override
-  protected void tearDown() throws Exception {
-    super.tearDown();
-  }
-
   private static void setUpHgrc(VirtualFile repository) {
     cd(".hg");
     File pluginRoot = new File(PluginPathManager.getPluginHomePath("hg4idea"));

From de6f16f4fb51da412a29714e303834d5b627315e Mon Sep 17 00:00:00 2001
From: Vassiliy Kudryashov <Vassiliy.Kudryashov@jetbrains.com>
Date: Thu, 28 Feb 2013 13:56:17 +0400
Subject: [PATCH 333/354] better toHex

---
 .../intellij/codeInsight/daemon/impl/JavaColorProvider.java    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java
index 47e56b27c6e2..dfc7169a2777 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/JavaColorProvider.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.editor.ElementColorProvider;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.JavaConstantExpressionEvaluator;
 import com.intellij.psi.util.PsiTypesUtil;
+import com.intellij.ui.ColorUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -147,7 +148,7 @@ public class JavaColorProvider implements ElementColorProvider {
   private static void replaceInt(PsiExpression expr, int newValue, boolean hex) {
     PsiElementFactory factory = JavaPsiFacade.getElementFactory(expr.getProject());
     if (getInt(expr) != newValue) {
-      String text = hex ? "0x" + Integer.toHexString(newValue & 0x00ffffff).toUpperCase() : Integer.toString(newValue);
+      String text = hex ? "0x" + ColorUtil.toHex(new Color(newValue)).toUpperCase() : Integer.toString(newValue);
       expr.replace(factory.createExpressionFromText(text, null));
     }
   }

From f9517a1657f208fe351e26142084bc4fa0be305c Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 14:22:07 +0400
Subject: [PATCH 334/354] IDEA-101635 ManageProjectTemplates: multiple
 templates deleting works incorrectly

---
 .../templates/LocalArchivedTemplate.java      |  4 ++
 .../ManageProjectTemplatesDialog.java         | 31 +++++++++----
 .../src/com/intellij/ui/ListDataAdapter.java  | 43 -------------------
 3 files changed, 26 insertions(+), 52 deletions(-)
 delete mode 100644 platform/platform-api/src/com/intellij/ui/ListDataAdapter.java

diff --git a/java/idea-ui/src/com/intellij/platform/templates/LocalArchivedTemplate.java b/java/idea-ui/src/com/intellij/platform/templates/LocalArchivedTemplate.java
index 0a76c6968392..bb17553b3fe4 100644
--- a/java/idea-ui/src/com/intellij/platform/templates/LocalArchivedTemplate.java
+++ b/java/idea-ui/src/com/intellij/platform/templates/LocalArchivedTemplate.java
@@ -147,4 +147,8 @@ public class LocalArchivedTemplate extends ArchivedProjectTemplate {
   public ZipInputStream getStream() throws IOException {
     return new ZipInputStream(myArchivePath.openStream());
   }
+
+  public URL getArchivePath() {
+    return myArchivePath;
+  }
 }
diff --git a/java/idea-ui/src/com/intellij/platform/templates/ManageProjectTemplatesDialog.java b/java/idea-ui/src/com/intellij/platform/templates/ManageProjectTemplatesDialog.java
index b122ebb2cf4c..81d9b7fc4b7f 100644
--- a/java/idea-ui/src/com/intellij/platform/templates/ManageProjectTemplatesDialog.java
+++ b/java/idea-ui/src/com/intellij/platform/templates/ManageProjectTemplatesDialog.java
@@ -21,17 +21,22 @@ import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.platform.ProjectTemplate;
 import com.intellij.platform.ProjectTemplatesFactory;
-import com.intellij.ui.*;
+import com.intellij.ui.CollectionListModel;
+import com.intellij.ui.ColoredListCellRenderer;
+import com.intellij.ui.ScrollPaneFactory;
+import com.intellij.ui.ToolbarDecorator;
 import com.intellij.ui.components.JBList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
-import javax.swing.event.ListDataEvent;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import java.awt.*;
 import java.awt.event.ActionEvent;
+import java.io.File;
+import java.net.URISyntaxException;
+import java.net.URL;
 import java.util.Arrays;
 
 /**
@@ -49,7 +54,21 @@ class ManageProjectTemplatesDialog extends DialogWrapper {
     setTitle("Manage Project Templates");
     final ProjectTemplate[] templates =
       new ArchivedTemplatesFactory().createTemplates(ProjectTemplatesFactory.CUSTOM_GROUP, new WizardContext(null));
-    final CollectionListModel<ProjectTemplate> model = new CollectionListModel<ProjectTemplate>(Arrays.asList(templates));
+    final CollectionListModel<ProjectTemplate> model = new CollectionListModel<ProjectTemplate>(Arrays.asList(templates)) {
+      @Override
+      public void remove(int index) {
+        ProjectTemplate template = getElementAt(index);
+        super.remove(index);
+        if (template instanceof LocalArchivedTemplate) {
+          URL path = ((LocalArchivedTemplate)template).getArchivePath();
+          try {
+            new File(path.toURI()).delete();
+          }
+          catch (URISyntaxException ignore) {
+          }
+        }
+      }
+    };
     myTemplatesList = new JBList(model);
     myTemplatesList.setEmptyText("No user-defined project templates");
     myTemplatesList.setPreferredSize(new Dimension(300, 100));
@@ -66,12 +85,6 @@ class ManageProjectTemplatesDialog extends DialogWrapper {
         myDescriptionPane.setText(template == null ? null : template.getDescription());
       }
     });
-    model.addListDataListener(new ListDataAdapter() {
-      @Override
-      public void intervalRemoved(ListDataEvent e) {
-        ArchivedTemplatesFactory.getTemplateFile(templates[e.getIndex0()].getName()).delete();
-      }
-    });
 
     myPanel = new JPanel(new BorderLayout(0, 5));
     myPanel.add(ToolbarDecorator.createDecorator(myTemplatesList).disableUpDownActions().createPanel());
diff --git a/platform/platform-api/src/com/intellij/ui/ListDataAdapter.java b/platform/platform-api/src/com/intellij/ui/ListDataAdapter.java
deleted file mode 100644
index 255346d6c784..000000000000
--- a/platform/platform-api/src/com/intellij/ui/ListDataAdapter.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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.ui;
-
-import javax.swing.event.ListDataEvent;
-import javax.swing.event.ListDataListener;
-
-/**
- * @author Dmitry Avdeev
- *         Date: 11/14/12
- */
-public class ListDataAdapter implements ListDataListener {
-  @Override
-  public void intervalAdded(ListDataEvent e) {
-    dataChanged(e);
-  }
-
-  @Override
-  public void intervalRemoved(ListDataEvent e) {
-    dataChanged(e);
-  }
-
-  @Override
-  public void contentsChanged(ListDataEvent e) {
-    dataChanged(e);
-  }
-
-  protected void dataChanged(ListDataEvent e) {
-  }
-}

From 516e807a677b1a96503b1091d3767a872e79b970 Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Thu, 28 Feb 2013 11:32:50 +0100
Subject: [PATCH 335/354] be prepared that file's language may be plain text
 whilst view provider has some other language (IDEA-101709, IDEA-101980)

this can happen if the base language has no parser definition (e.g. batch plugin)
---
 .../intellij/psi/AbstractReparseTestCase.java | 34 +++++++++++--------
 .../impl/source/text/BlockSupportImpl.java    |  7 +++-
 2 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/java/testFramework/src/com/intellij/psi/AbstractReparseTestCase.java b/java/testFramework/src/com/intellij/psi/AbstractReparseTestCase.java
index 43bf6ccc20ec..d1ad8a4c4d33 100644
--- a/java/testFramework/src/com/intellij/psi/AbstractReparseTestCase.java
+++ b/java/testFramework/src/com/intellij/psi/AbstractReparseTestCase.java
@@ -34,7 +34,7 @@ public abstract class AbstractReparseTestCase extends PsiTestCase {
             String expectedNewText = oldText.substring(0, myInsertOffset) + s + oldText.substring(myInsertOffset);
 
             try {
-              doReparse(s, expectedNewText, 0);
+              doReparseAndCheck(s, expectedNewText, 0);
             }
             catch (IncorrectOperationException e) {
               LOG.error(e);
@@ -62,11 +62,27 @@ public abstract class AbstractReparseTestCase extends PsiTestCase {
     String oldText = myDummyFile.getText();
     String expectedNewText = oldText.substring(0, myInsertOffset-count) + oldText.substring(myInsertOffset);
 
-    doReparse("", expectedNewText, count);
+    doReparseAndCheck("", expectedNewText, count);
     myInsertOffset -= count;
   }
 
-  protected void doReparse(final String s, final String expectedNewText, final int length) throws IncorrectOperationException {
+  private void doReparseAndCheck(final String s, final String expectedNewText, final int length) throws IncorrectOperationException {
+    doReparse(s, length);
+    String foundStructure = DebugUtil.treeToString(SourceTreeToPsiMap.psiElementToTree(myDummyFile), false);
+    final PsiFile psiFile = createDummyFile(getName() + "." + myFileType.getDefaultExtension(), expectedNewText);
+    String expectedStructure = DebugUtil.treeToString(SourceTreeToPsiMap.psiElementToTree(psiFile), false);
+    if (!expectedStructure.equals(foundStructure)) {
+      System.out.println("expected: ");
+      System.out.println(expectedStructure);
+      System.out.println("found: ");
+      System.out.println(foundStructure);
+      assertEquals(expectedStructure, foundStructure);
+    }
+
+    assertEquals("Reparse tree should be equal to the document", expectedNewText, myDummyFile.getText());
+  }
+
+  protected void doReparse(final String s, final int length) {
     CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
       @Override
       public void run() {
@@ -76,18 +92,6 @@ public abstract class AbstractReparseTestCase extends PsiTestCase {
             BlockSupport blockSupport = ServiceManager.getService(myProject, BlockSupport.class);
             try {
               blockSupport.reparseRange(myDummyFile, myInsertOffset - length, myInsertOffset, s);
-              String foundStructure = DebugUtil.treeToString(SourceTreeToPsiMap.psiElementToTree(myDummyFile), false);
-              final PsiFile psiFile = createDummyFile(getName() + "." + myFileType.getDefaultExtension(), expectedNewText);
-              String expectedStructure = DebugUtil.treeToString(SourceTreeToPsiMap.psiElementToTree(psiFile), false);
-              if (!expectedStructure.equals(foundStructure)) {
-                System.out.println("expected: ");
-                System.out.println(expectedStructure);
-                System.out.println("found: ");
-                System.out.println(foundStructure);
-                assertEquals(expectedStructure, foundStructure);
-              }
-
-              assertEquals("Reparse tree should be equal to the document",expectedNewText,myDummyFile.getText());
             }
             catch (IncorrectOperationException e) {
               LOG.error(e);
diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java b/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
index c867da4dbc7b..0a13a9938838 100644
--- a/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
+++ b/platform/core-impl/src/com/intellij/psi/impl/source/text/BlockSupportImpl.java
@@ -23,6 +23,7 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.ex.DocumentBulkUpdateListener;
 import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.openapi.fileTypes.PlainTextLanguage;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Ref;
@@ -188,7 +189,11 @@ public class BlockSupportImpl extends BlockSupport {
       copy.getLanguages();
       Language language = fileImpl.getLanguage();
       SingleRootFileViewProvider.doNotCheckFileSizeLimit(lightFile); // optimization: do not convert file contents to bytes to determine if we should codeinsight it
-      final PsiFileImpl newFile = (PsiFileImpl)copy.getPsi(language);
+      PsiFileImpl newFile = (PsiFileImpl)copy.getPsi(language);
+
+      if (newFile == null && language == PlainTextLanguage.INSTANCE && fileImpl == viewProvider.getPsi(viewProvider.getBaseLanguage())) {
+        newFile = (PsiFileImpl)copy.getPsi(copy.getBaseLanguage());
+      }
 
       if (newFile == null) {
         throw new RuntimeException("View provider " + viewProvider + " refused to parse text with " + language +

From e3d97bf8ee1f363cece04097cb576c25e87887bd Mon Sep 17 00:00:00 2001
From: Bas Leijdekkers <basleijdekkers@gmail.com>
Date: Thu, 28 Feb 2013 11:40:01 +0100
Subject: [PATCH 336/354] IDEA-101944 ("Pointless boolean expression"
 inspection with multiple '&&' fails)

---
 .../PointlessBooleanExpressionInspection.java | 22 ++++++++++++++-----
 .../PointlessBooleanExpression.java           |  7 ++++++
 .../expected.xml                              |  7 ++++++
 ...ntlessBooleanExpressionInspectionTest.java |  4 ++--
 4 files changed, 32 insertions(+), 8 deletions(-)
 rename plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/{pointless_boolean_expression_ignore_cont_const => pointless_boolean_expression}/PointlessBooleanExpression.java (81%)
 rename plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/{pointless_boolean_expression_ignore_cont_const => pointless_boolean_expression}/expected.xml (82%)

diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspection.java
index b522c2f1e176..953bbe18e771 100644
--- a/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspection.java
+++ b/plugins/InspectionGadgets/src/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspection.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2003-2012 Dave Griffith, Bas Leijdekkers
+ * Copyright 2003-2013 Dave Griffith, Bas Leijdekkers
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -183,17 +183,19 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
       }
       buildSimplifiedExpression(expressions, "==", negate, out);
     }
+    else {
+      out.append(expression.getText());
+    }
   }
 
   private void buildSimplifiedExpression(List<PsiExpression> expressions, String token, boolean negate, StringBuilder out) {
     if (expressions.size() == 1) {
       final PsiExpression expression = expressions.get(0);
-      final String expressionText = expression.getText();
       if (isBoxedTypeComparison(token, expression)) {
-        out.append(expressionText).append(" != null && ");
+        out.append(expression.getText()).append(" != null && ");
       }
       if (!negate) {
-        out.append(expressionText);
+        out.append(expression.getText());
         return;
       }
       if (ComparisonUtils.isComparison(expression)) {
@@ -206,10 +208,10 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
       }
       else {
         if (ParenthesesUtils.getPrecedence(expression) > ParenthesesUtils.PREFIX_PRECEDENCE) {
-          out.append("!(").append(expressionText).append(')');
+          out.append("!(").append(expression.getText()).append(')');
         }
         else {
-          out.append('!').append(expressionText);
+          out.append('!').append(expression.getText());
         }
       }
     }
@@ -221,11 +223,19 @@ public class PointlessBooleanExpressionInspection extends BaseInspection {
       for (PsiExpression expression : expressions) {
         if (useToken) {
           out.append(token);
+          final PsiElement previousSibling = expression.getPrevSibling();
+          if (previousSibling instanceof PsiWhiteSpace) {
+            out.append(previousSibling.getText());
+          }
         }
         else {
           useToken = true;
         }
         buildSimplifiedExpression(expression, out);
+        final PsiElement nextSibling = expression.getNextSibling();
+        if (nextSibling instanceof PsiWhiteSpace) {
+          out.append(nextSibling.getText());
+        }
       }
       if (negate) {
         out.append(')');
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/PointlessBooleanExpression.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/PointlessBooleanExpression.java
similarity index 81%
rename from plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/PointlessBooleanExpression.java
rename to plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/PointlessBooleanExpression.java
index 15020be28068..0cfd2f6840ba 100644
--- a/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/PointlessBooleanExpression.java
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/PointlessBooleanExpression.java
@@ -28,4 +28,11 @@ class PointlessBooleanExpression {
     boolean y = false || c;
     boolean z = b != true;
   }
+}
+class Presley {
+  void elvis(Object king) {
+    if (true && king != null && king.hashCode() > 1) {
+      // blah
+    }
+  }
 }
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/expected.xml b/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/expected.xml
similarity index 82%
rename from plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/expected.xml
rename to plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/expected.xml
index 1d0a66df6e32..32f91701b161 100644
--- a/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const/expected.xml
+++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/controlflow/pointless_boolean_expression/expected.xml
@@ -42,4 +42,11 @@
     <description>&lt;code&gt;b != true&lt;/code&gt; can be simplified to '!b' #loc</description>
   </problem>
 
+  <problem>
+    <file>PointlessBooleanExpression.java</file>
+    <line>34</line>
+    <problem_class severity="WARNING" attribute_key="WARNING_ATTRIBUTES">Pointless boolean expression</problem_class>
+    <description>&lt;code&gt;true &amp;&amp; king != null &amp;&amp; king.hashCode() &gt; 1&lt;/code&gt; can be simplified to 'king != null &amp;&amp; king.hashCode() &gt; 1' #loc</description>
+  </problem>
+
 </problems>
diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspectionTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspectionTest.java
index 5c213bf5c00e..fb1751dc2d55 100644
--- a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspectionTest.java
+++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/controlflow/PointlessBooleanExpressionInspectionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2012 JetBrains s.r.o.
+ * Copyright 2000-2013 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.
@@ -25,6 +25,6 @@ public class PointlessBooleanExpressionInspectionTest extends IGInspectionTestCa
   public void test() throws Exception {
     final PointlessBooleanExpressionInspection inspection = new PointlessBooleanExpressionInspection();
     inspection.m_ignoreExpressionsContainingConstants = true;
-    doTest("com/siyeh/igtest/controlflow/pointless_boolean_expression_ignore_cont_const", inspection);
+    doTest("com/siyeh/igtest/controlflow/pointless_boolean_expression", inspection);
   }
 }
\ No newline at end of file

From a553950319259dd74fc0acdb65d5d22cc99e4272 Mon Sep 17 00:00:00 2001
From: Dmitry Jemerov <yole@jetbrains.com>
Date: Thu, 28 Feb 2013 11:40:16 +0100
Subject: [PATCH 337/354] nicer API for plugins to modify inspection tool
 settings

---
 .../codeInspection/InspectionProfile.java     | 19 +++++++++++++++++-
 .../ex/InspectionProfileImpl.java             | 20 +++++++++++++++++++
 .../InspectionProjectProfileManager.java      |  3 +++
 ...ddCustomTagOrAttributeIntentionAction.java | 15 +++++++-------
 ...dHtmlTagOrAttributeToCustomsIntention.java | 17 +++++++++-------
 .../HtmlUnknownAttributeInspection.java       |  4 +++-
 .../HtmlUnknownTagInspection.java             |  5 +++--
 .../RequiredAttributesInspection.java         |  7 +++++--
 8 files changed, 70 insertions(+), 20 deletions(-)

diff --git a/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java b/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
index 07766bacc783..5b8528fa65ca 100644
--- a/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
+++ b/platform/lang-api/src/com/intellij/codeInspection/InspectionProfile.java
@@ -19,6 +19,7 @@ package com.intellij.codeInspection;
 import com.intellij.codeHighlighting.HighlightDisplayLevel;
 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Key;
 import com.intellij.profile.Profile;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.Consumer;
@@ -34,7 +35,7 @@ public interface InspectionProfile extends Profile {
   HighlightDisplayLevel getErrorLevel(@NotNull HighlightDisplayKey inspectionToolKey, PsiElement element);
 
   /**
-   * If you need to modify tool's settings, please use {@link #modifyProfile(com.intellij.util.Consumer)}
+   * If you need to modify tool's settings, please use {@link #modifyToolSettings}
    */
   InspectionProfileEntry getInspectionTool(@NotNull String shortName, @NotNull PsiElement element);
 
@@ -44,8 +45,24 @@ public interface InspectionProfile extends Profile {
   /** Returns (unwrapped) inspection */
   InspectionProfileEntry getUnwrappedTool(@NotNull String shortName, @NotNull PsiElement element);
 
+  /** Returns (unwrapped) inspection */
+  <T extends InspectionProfileEntry>
+  T getUnwrappedTool(@NotNull Key<T> shortNameKey, @NotNull PsiElement element);
+
   void modifyProfile(Consumer<ModifiableModel> modelConsumer);
 
+  /**
+   * Allows a plugin to modify the settings of the inspection tool with the specified ID programmatically, without going through
+   * the settings dialog.
+   *
+   * @param shortNameKey the ID of the tool to change.
+   * @param psiElement the element for which the settings should be changed.
+   * @param toolConsumer the callback that receives the tool.
+   * @since 12.1
+   */
+  <T extends InspectionProfileEntry>
+  void modifyToolSettings(Key<T> shortNameKey, @NotNull PsiElement psiElement, Consumer<T> toolConsumer);
+
   /**
    * @param element context element
    * @return all (both enabled and disabled) tools
diff --git a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
index f07f264c0a3a..4a08748b83ce 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/ex/InspectionProfileImpl.java
@@ -339,6 +339,12 @@ public class InspectionProfileImpl extends ProfileEx implements ModifiableModel,
     return tool instanceof InspectionToolWrapper ? ((InspectionToolWrapper)tool).getTool() : tool;
   }
 
+  @Override
+  public <T extends InspectionProfileEntry> T getUnwrappedTool(@NotNull Key<T> shortNameKey, @NotNull PsiElement element) {
+    //noinspection unchecked
+    return (T) getUnwrappedTool(shortNameKey.toString(), element);
+  }
+
   @Override
   public void modifyProfile(Consumer<ModifiableModel> modelConsumer) {
     ModifiableModel model = getModifiableModel();
@@ -351,6 +357,20 @@ public class InspectionProfileImpl extends ProfileEx implements ModifiableModel,
     }
   }
 
+  @Override
+  public <T extends InspectionProfileEntry> void modifyToolSettings(final Key<T> shortNameKey,
+                                                                    @NotNull final PsiElement psiElement,
+                                                                    final Consumer<T> toolConsumer) {
+    modifyProfile(new Consumer<ModifiableModel>() {
+      @Override
+      public void consume(ModifiableModel model) {
+        InspectionProfileEntry tool = model.getUnwrappedTool(shortNameKey.toString(), psiElement);
+        //noinspection unchecked
+        toolConsumer.consume((T) tool);
+      }
+    });
+  }
+
   @Override
   @Nullable
   public InspectionProfileEntry getInspectionTool(@NotNull String shortName) {
diff --git a/platform/lang-impl/src/com/intellij/profile/codeInspection/InspectionProjectProfileManager.java b/platform/lang-impl/src/com/intellij/profile/codeInspection/InspectionProjectProfileManager.java
index 306d83e9114f..1313d61def43 100644
--- a/platform/lang-impl/src/com/intellij/profile/codeInspection/InspectionProjectProfileManager.java
+++ b/platform/lang-impl/src/com/intellij/profile/codeInspection/InspectionProjectProfileManager.java
@@ -111,6 +111,9 @@ public class InspectionProjectProfileManager extends DefaultProjectProfileManage
     return (InspectionProfile)getProjectProfileImpl();
   }
 
+  /**
+   * @deprecated  use {@link #getInspectionProfile()} instead
+   */
   @SuppressWarnings({"UnusedDeclaration"})
   @NotNull
   public InspectionProfile getInspectionProfile(PsiElement element){
diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
index ce0d01ef3cc2..ba84b96d3f62 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddCustomTagOrAttributeIntentionAction.java
@@ -16,10 +16,11 @@
 
 package com.intellij.codeInspection.htmlInspections;
 
+import com.intellij.codeInspection.InspectionProfile;
 import com.intellij.codeInspection.LocalQuickFix;
-import com.intellij.codeInspection.ModifiableModel;
 import com.intellij.codeInspection.ProblemDescriptor;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Key;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.Consumer;
@@ -32,10 +33,10 @@ import org.jetbrains.annotations.NotNull;
 public class AddCustomTagOrAttributeIntentionAction implements LocalQuickFix {
   private final String myName;
   private final int myType;
-  private final String myInspectionName;
+  @NotNull private final Key<HtmlUnknownTagInspection> myInspectionKey;
 
-  public AddCustomTagOrAttributeIntentionAction(@NotNull String shortName, String name, int type) {
-    myInspectionName = shortName;
+  public AddCustomTagOrAttributeIntentionAction(@NotNull Key<HtmlUnknownTagInspection> inspectionKey, String name, int type) {
+    myInspectionKey = inspectionKey;
     myName = name;
     myType = type;
   }
@@ -65,10 +66,10 @@ public class AddCustomTagOrAttributeIntentionAction implements LocalQuickFix {
   public void applyFix(@NotNull final Project project, @NotNull final ProblemDescriptor descriptor) {
     final PsiElement element = descriptor.getPsiElement();
 
-    InspectionProjectProfileManager.getInstance(project).getInspectionProfile().modifyProfile(new Consumer<ModifiableModel>() {
+    InspectionProfile profile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
+    profile.modifyToolSettings(myInspectionKey, element, new Consumer<HtmlUnknownTagInspection>() {
       @Override
-      public void consume(ModifiableModel model) {
-        HtmlUnknownTagInspection tool = (HtmlUnknownTagInspection)model.getUnwrappedTool(myInspectionName, element);
+      public void consume(HtmlUnknownTagInspection tool) {
         tool.addCustomPropertyName(myName);
       }
     });
diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
index 63be9c5ab72d..78366a2c0ab1 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/AddHtmlTagOrAttributeToCustomsIntention.java
@@ -17,9 +17,11 @@
 package com.intellij.codeInspection.htmlInspections;
 
 import com.intellij.codeInsight.intention.IntentionAction;
-import com.intellij.codeInspection.ModifiableModel;
+import com.intellij.codeInspection.InspectionProfile;
+import com.intellij.codeInspection.InspectionProfileEntry;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Key;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
 import com.intellij.psi.PsiFile;
 import com.intellij.util.Consumer;
@@ -33,10 +35,10 @@ import org.jetbrains.annotations.NotNull;
 public class AddHtmlTagOrAttributeToCustomsIntention implements IntentionAction {
   private final String myName;
   private final int myType;
-  private final String myInspectionName;
+  private final Key<InspectionProfileEntry> myInspectionKey;
 
-  public AddHtmlTagOrAttributeToCustomsIntention(String shortName, String name, int type) {
-    myInspectionName = shortName;
+  public AddHtmlTagOrAttributeToCustomsIntention(Key<InspectionProfileEntry> inspectionKey, String name, int type) {
+    myInspectionKey = inspectionKey;
     myName = name;
     myType = type;
   }
@@ -68,10 +70,11 @@ public class AddHtmlTagOrAttributeToCustomsIntention implements IntentionAction
   }
 
   public void invoke(@NotNull Project project, Editor editor, final PsiFile file) throws IncorrectOperationException {
-    InspectionProjectProfileManager.getInstance(project).getInspectionProfile().modifyProfile(new Consumer<ModifiableModel>() {
+    InspectionProfile profile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
+    profile.modifyToolSettings(myInspectionKey, file, new Consumer<InspectionProfileEntry>() {
       @Override
-      public void consume(ModifiableModel model) {
-        XmlEntitiesInspection xmlEntitiesInspection = (XmlEntitiesInspection)model.getUnwrappedTool(myInspectionName, file);
+      public void consume(InspectionProfileEntry entry) {
+        XmlEntitiesInspection xmlEntitiesInspection = (XmlEntitiesInspection) entry;
         xmlEntitiesInspection.setAdditionalEntries(myType, appendName(xmlEntitiesInspection.getAdditionalEntries(myType)));
       }
     });
diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownAttributeInspection.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownAttributeInspection.java
index 9dac096fc6db..58617e8d1b29 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownAttributeInspection.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownAttributeInspection.java
@@ -22,6 +22,7 @@ import com.intellij.codeInspection.ProblemHighlightType;
 import com.intellij.codeInspection.ProblemsHolder;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Key;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.html.HtmlTag;
 import com.intellij.psi.xml.XmlAttribute;
@@ -44,6 +45,7 @@ public class HtmlUnknownAttributeInspection extends HtmlUnknownTagInspection {
 
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInspection.htmlInspections.HtmlUnknownAttributeInspection");
   @NonNls public static final String ATTRIBUTE_SHORT_NAME = "HtmlUnknownAttribute";
+  public static final Key<HtmlUnknownTagInspection> ATTRIBUTE_KEY = Key.create(ATTRIBUTE_SHORT_NAME);
 
   public HtmlUnknownAttributeInspection() {
     super("");
@@ -100,7 +102,7 @@ public class HtmlUnknownAttributeInspection extends HtmlUnknownTagInspection {
 
           boolean maySwitchToHtml5 = HtmlUtil.isCustomHtml5Attribute(name) && !HtmlUtil.hasNonHtml5Doctype(tag);
           LocalQuickFix[] quickfixes = new LocalQuickFix[maySwitchToHtml5 ? 3 : 2];
-          quickfixes[0] = new AddCustomTagOrAttributeIntentionAction(getShortName(), name, XmlEntitiesInspection.UNKNOWN_ATTRIBUTE);
+          quickfixes[0] = new AddCustomTagOrAttributeIntentionAction(ATTRIBUTE_KEY, name, XmlEntitiesInspection.UNKNOWN_ATTRIBUTE);
           quickfixes[1] = new RemoveAttributeIntentionAction(name);
           if (maySwitchToHtml5) {
             quickfixes[2] = new SwitchToHtml5WithHighPriorityAction();
diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownTagInspection.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownTagInspection.java
index 08ab3339463f..38a54cd7d944 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownTagInspection.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/HtmlUnknownTagInspection.java
@@ -24,6 +24,7 @@ import com.intellij.codeInspection.ProblemHighlightType;
 import com.intellij.codeInspection.ProblemsHolder;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.JDOMExternalizableStringList;
+import com.intellij.openapi.util.Key;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.html.HtmlTag;
 import com.intellij.psi.impl.source.html.dtd.HtmlElementDescriptorImpl;
@@ -43,7 +44,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
-import javax.swing.border.EmptyBorder;
 import javax.swing.event.DocumentEvent;
 import javax.swing.text.BadLocationException;
 import javax.swing.text.Document;
@@ -63,6 +63,7 @@ public class HtmlUnknownTagInspection extends HtmlLocalInspectionTool {
   public JDOMExternalizableStringList myValues;
   public boolean myCustomValuesEnabled = true;
   @NonNls public static final String TAG_SHORT_NAME = "HtmlUnknownTag";
+  public static final Key<HtmlUnknownTagInspection> TAG_KEY = Key.create(TAG_SHORT_NAME);
 
   public HtmlUnknownTagInspection() {
     this("nobr,noembed,comment,noscript,embed,script");
@@ -229,7 +230,7 @@ public class HtmlUnknownTagInspection extends HtmlLocalInspectionTool {
 
       if (!isCustomValuesEnabled() || !isCustomValue(name)) {
         final AddCustomTagOrAttributeIntentionAction action =
-          new AddCustomTagOrAttributeIntentionAction(getShortName(), name, XmlEntitiesInspection.UNKNOWN_TAG);
+          new AddCustomTagOrAttributeIntentionAction(TAG_KEY, name, XmlEntitiesInspection.UNKNOWN_TAG);
 
         // todo: support "element is not allowed" message for html5
         // some tags in html5 cannot be found in xhtml5.xsd if they are located in incorrect context, so they get any-element descriptor (ex. "canvas: tag)
diff --git a/xml/impl/src/com/intellij/codeInspection/htmlInspections/RequiredAttributesInspection.java b/xml/impl/src/com/intellij/codeInspection/htmlInspections/RequiredAttributesInspection.java
index d4cdffe1d274..bde145d007a8 100644
--- a/xml/impl/src/com/intellij/codeInspection/htmlInspections/RequiredAttributesInspection.java
+++ b/xml/impl/src/com/intellij/codeInspection/htmlInspections/RequiredAttributesInspection.java
@@ -16,11 +16,13 @@
 package com.intellij.codeInspection.htmlInspections;
 
 import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.codeInspection.InspectionProfileEntry;
 import com.intellij.codeInspection.InspectionsBundle;
-import com.intellij.codeInspection.XmlSuppressableInspectionTool;
 import com.intellij.codeInspection.XmlInspectionGroupNames;
+import com.intellij.codeInspection.XmlSuppressableInspectionTool;
 import com.intellij.codeInspection.ex.UnfairLocalInspectionTool;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Key;
 import com.intellij.ui.DocumentAdapter;
 import com.intellij.ui.FieldPanel;
 import org.jetbrains.annotations.NonNls;
@@ -43,6 +45,7 @@ public class RequiredAttributesInspection extends XmlSuppressableInspectionTool
 
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInspection.htmlInspections.RequiredAttributesInspection");
   @NonNls public static final String SHORT_NAME = "RequiredAttributes";
+  @NonNls public static final Key<InspectionProfileEntry> SHORT_NAME_KEY = Key.create(SHORT_NAME);
 
   @NotNull
   public String getGroupDisplayName() {
@@ -87,7 +90,7 @@ public class RequiredAttributesInspection extends XmlSuppressableInspectionTool
   }
 
   public IntentionAction getIntentionAction(String name, int type) {
-    return new AddHtmlTagOrAttributeToCustomsIntention(getShortName(), name, type);
+    return new AddHtmlTagOrAttributeToCustomsIntention(SHORT_NAME_KEY, name, type);
   }
 
   public String getAdditionalEntries(int type) {

From c6e4e760a74f3bd6225662990524b277a2b23550 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Tue, 26 Feb 2013 16:10:35 +0400
Subject: [PATCH 338/354] already disposed

---
 .../openapi/fileEditor/impl/text/TextEditorComponent.java   | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
index 89129280b1f8..1e7126451025 100644
--- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
+++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/TextEditorComponent.java
@@ -244,8 +244,10 @@ class TextEditorComponent extends JBLoadingPanel implements DataProvider{
    * changes its file type.
    */
   private void updateHighlighters(){
-    final EditorHighlighter highlighter = EditorHighlighterFactory.getInstance().createEditorHighlighter(myProject, myFile);
-    ((EditorEx)myEditor).setHighlighter(highlighter);
+    if (!myProject.isDisposed()) {
+      final EditorHighlighter highlighter = EditorHighlighterFactory.getInstance().createEditorHighlighter(myProject, myFile);
+      ((EditorEx)myEditor).setHighlighter(highlighter);
+    }
   }
 
   /**

From 8d28b400c0086ef3588caf02d3f72ec3d358c0e1 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Wed, 27 Feb 2013 12:44:32 +0400
Subject: [PATCH 339/354] cleanup

---
 .../ui/components/JBLoadingPanel.java         |  4 +-
 .../intellij/util/lang/ClasspathCache.java    | 81 ++++++++++++-------
 .../src/com/intellij/util/lang/JarLoader.java |  9 +++
 3 files changed, 65 insertions(+), 29 deletions(-)

diff --git a/platform/platform-api/src/com/intellij/ui/components/JBLoadingPanel.java b/platform/platform-api/src/com/intellij/ui/components/JBLoadingPanel.java
index d02d7bd25d47..f46e9dbbd63c 100644
--- a/platform/platform-api/src/com/intellij/ui/components/JBLoadingPanel.java
+++ b/platform/platform-api/src/com/intellij/ui/components/JBLoadingPanel.java
@@ -19,6 +19,7 @@ import com.intellij.openapi.Disposable;
 import com.intellij.openapi.ui.LoadingDecorator;
 import com.intellij.ui.ColorUtil;
 import com.intellij.ui.components.panels.NonOpaquePanel;
+import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.ui.AsyncProcessIcon;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
@@ -26,7 +27,6 @@ import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
 import java.awt.*;
-import java.util.ArrayList;
 import java.util.Collection;
 
 /**
@@ -35,7 +35,7 @@ import java.util.Collection;
 public class JBLoadingPanel extends JPanel {
   private final JPanel myPanel;
   final LoadingDecorator myDecorator;
-  private Collection<JBLoadingPanelListener> myListeners = new ArrayList<JBLoadingPanelListener>();
+  private final Collection<JBLoadingPanelListener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList();
 
   public JBLoadingPanel(@Nullable LayoutManager manager, @NotNull Disposable parent) {
     super(new BorderLayout());
diff --git a/platform/util/src/com/intellij/util/lang/ClasspathCache.java b/platform/util/src/com/intellij/util/lang/ClasspathCache.java
index 9acbbe87c104..8d4299e5ec49 100644
--- a/platform/util/src/com/intellij/util/lang/ClasspathCache.java
+++ b/platform/util/src/com/intellij/util/lang/ClasspathCache.java
@@ -42,21 +42,17 @@ public class ClasspathCache {
   private final TIntObjectHashMap<Object> myResourcePackagesCache = new TIntObjectHashMap<Object>();
   private final TIntObjectHashMap<Object> myClassPackagesCache = new TIntObjectHashMap<Object>();
 
-  private THashMap<String, Set<Loader>> myResources2LoadersTempMap = new THashMap<String, Set<Loader>>();
+  private Map<String, Set<Loader>> myResources2LoadersTempMap = new THashMap<String, Set<Loader>>();
   private static final double PROBABILITY = 0.005d;
   private Name2LoaderFilter myNameFilter;
   private boolean myTempMapMode = true;
 
   public ClasspathCache() {
-    if(doDebug) {
-      myDebugInfo = new DebugInfo();
-    } else {
-      myDebugInfo = null;
-    }
+    myDebugInfo = doDebug ? new DebugInfo() : new NullDebugInfo();
   }
 
   public void addResourceEntry(String resourcePath, Loader loader) {
-    if (doDebug) myDebugInfo.addResourceEntry(resourcePath, loader);
+    myDebugInfo.addResourceEntry(resourcePath, loader);
 
     String packageName = getPackageName(resourcePath);
     TIntObjectHashMap<Object> map = resourcePath.endsWith(UrlClassLoader.CLASS_EXTENSION) ?
@@ -75,8 +71,9 @@ public class ClasspathCache {
     }
   }
 
-  static abstract class LoaderIterator <ResultType, ParameterType, ParameterType2> {
-    abstract @Nullable ResultType process(Loader loader, ParameterType parameter, ParameterType2 parameter2);
+  abstract static class LoaderIterator <ResultType, ParameterType, ParameterType2> {
+    @Nullable
+    abstract ResultType process(Loader loader, ParameterType parameter, ParameterType2 parameter2);
   }
 
   @Nullable <ResultType, ParameterType, ParameterType2> ResultType iterateLoaders(
@@ -90,7 +87,7 @@ public class ClasspathCache {
     
     int hash = packageName.hashCode();
     Object o = map.get(hash);
-    if (doDebug) myDebugInfo.checkLoadersCount(resourcePath, o);    
+    myDebugInfo.checkLoadersCount(resourcePath, o);
       
     if (o == null) return null;
     if (o instanceof Loader) return iterator.process((Loader)o, parameter, parameter2);
@@ -107,11 +104,12 @@ public class ClasspathCache {
     return idx > 0 ? resourcePath.substring(0, idx) : "";
   }
 
-  private int registeredBeforeClose, registeredAfterClose;
+  private int registeredBeforeClose;
+  private int registeredAfterClose;
 
   public void addNameEntry(String name, Loader loader) {
     name = transformName(name);
-    if (doDebug) myDebugInfo.addNameEntry(name, loader);
+    myDebugInfo.addNameEntry(name, loader);
     if (myTempMapMode) {
       Set<Loader> loaders = myResources2LoadersTempMap.get(name);
       if (loaders == null) myResources2LoadersTempMap.put(name, loaders = new THashSet<Loader>());
@@ -128,9 +126,9 @@ public class ClasspathCache {
 
   public boolean loaderHasName(String name, Loader loader) {
     String origName = name;
-    boolean result;
     name = transformName(name);
-    
+
+    boolean result;
     if (myTempMapMode) {
       ++requests;
       Set<Loader> loaders = myResources2LoadersTempMap.get(name);
@@ -144,7 +142,7 @@ public class ClasspathCache {
           ++diffs3;
         }
         Resource resource = loader.getResource(origName, true);
-        if ((resource != null && !result) || (resource == null && result)) {
+        if (resource != null && !result || resource == null && result) {
           ++falseHits;
         }
       }
@@ -152,7 +150,8 @@ public class ClasspathCache {
       if (requests % 1000 == 0 && UrlClassLoader.doDebug) {
         UrlClassLoader.debug("Avoided disk hits: "+hits + " from " + requests + (doDebug ? ", false hits:" + falseHits + ", bitmap diffs:"+diffs3:""));
       }
-    } else {
+    }
+    else {
       ++requests2;
       result = myNameFilter.maybeContains(name, loader);
       if (!result) ++hits2;
@@ -185,7 +184,7 @@ public class ClasspathCache {
     return result;
   }
   
-  private String transformName(String name) {
+  private static String transformName(String name) {
     if (name.endsWith("/")) {
       name = name.substring(0, name.length() - 1);
     }
@@ -204,7 +203,15 @@ public class ClasspathCache {
     return name;
   }
 
-  private static int hits, requests, falseHits, requests2, hits2, falseHits2, diffs, diffs2, diffs3;
+  private static int hits;
+  private static int requests;
+  private static int falseHits;
+  private static int requests2;
+  private static int hits2;
+  private static int falseHits2;
+  private static int diffs;
+  private static int diffs2;
+  private static int diffs3;
 
   void nameSymbolsLoaded() {
     if (!myTempMapMode) {
@@ -220,7 +227,8 @@ public class ClasspathCache {
 
     myTempMapMode = false;
 
-    int nBits = 0, uniques = 0;
+    int nBits = 0;
+    int uniques = 0;
     for(Map.Entry<String, Set<Loader>> e:myResources2LoadersTempMap.entrySet()) {
       int size = e.getValue().size();
       if (size == 1) {
@@ -260,14 +268,14 @@ public class ClasspathCache {
       return maybeContains(hash, hash2);
     }
 
-    void add(String name, Loader loader) {
+    private void add(String name, Loader loader) {
       int hash = hashFromNameAndLoader(name, loader, StringHash.murmur(name, SEED));
       int hash2 = hashFromNameAndLoader(name, loader, hash);
 
       addIt(hash, hash2);
     }
 
-    private int hashFromNameAndLoader(String name, Loader loader, int n) {
+    private static int hashFromNameAndLoader(String name, Loader loader, int n) {
       int hash = StringHash.murmur(name, n);
       int i = loader.getIndex();
       while (i > 0) {
@@ -278,7 +286,7 @@ public class ClasspathCache {
     }
   }
 
-  static class DebugInfo {
+  private static class DebugInfo {
     private final HashMap<String, List<Loader>> myClassPackagesCache = new HashMap<String, List<Loader>>();
     private final HashMap<String, List<Loader>> myResourcePackagesCache = new HashMap<String, List<Loader>>();
     private final TIntHashSet myResourceIndex = new TIntHashSet();
@@ -298,19 +306,19 @@ public class ClasspathCache {
       return list;
     }
 
-    private void addResourceEntry(String resourcePath, Loader loader) {
+    protected void addResourceEntry(String resourcePath, Loader loader) {
       final List<Loader> loaders = getLoaders(resourcePath);
       if (!loaders.contains(loader)) { // TODO Make linked hash set instead?
         loaders.add(loader);
       }
     }
 
-    private void addNameEntry(String name, Loader loader) {
+    protected void addNameEntry(String name, Loader loader) {
       int hash = hashFromNameAndLoader(name, loader);
       myResourceIndex.add(hash);
     }
 
-    private int hashFromNameAndLoader(String name, Loader loader) {
+    protected static int hashFromNameAndLoader(String name, Loader loader) {
       int hash = name.hashCode();
       int i = loader.getIndex();
       while(i > 0) {
@@ -322,7 +330,7 @@ public class ClasspathCache {
 
     public void checkLoadersCount(String resourcePath, Object o) {
       List<Loader> loaders1 = getLoaders(resourcePath);
-      if (o == null && loaders1.size() != 0 ||
+      if (o == null && !loaders1.isEmpty() ||
           o instanceof Loader && loaders1.size() != 1 ||
           o instanceof Loader[] && loaders1.size() != ((Loader[])o).length
         ) {
@@ -330,8 +338,27 @@ public class ClasspathCache {
       }
     }
 
-    private boolean loaderHashName(String name, Loader loader) {
+    protected boolean loaderHashName(String name, Loader loader) {
       return myResourceIndex.contains(hashFromNameAndLoader(name, loader));
     }
   }
+
+  private static class NullDebugInfo extends DebugInfo {
+    @Override
+    public void checkLoadersCount(String resourcePath, Object o) {
+    }
+
+    @Override
+    protected void addResourceEntry(String resourcePath, Loader loader) {
+    }
+
+    @Override
+    protected void addNameEntry(String name, Loader loader) {
+    }
+
+    @Override
+    protected boolean loaderHashName(String name, Loader loader) {
+      return false;
+    }
+  }
 }
diff --git a/platform/util/src/com/intellij/util/lang/JarLoader.java b/platform/util/src/com/intellij/util/lang/JarLoader.java
index f574aa16a55b..47920fe5f469 100644
--- a/platform/util/src/com/intellij/util/lang/JarLoader.java
+++ b/platform/util/src/com/intellij/util/lang/JarLoader.java
@@ -42,6 +42,7 @@ class JarLoader extends Loader {
   private static final Logger LOG = Logger.getInstance(JarLoader.class);
 
   private final TimedComputable<ZipFile> myZipFileRef = new TimedComputable<ZipFile>(null) {
+    @Override
     @NotNull
     protected ZipFile calc() {
       try {
@@ -123,6 +124,7 @@ class JarLoader extends Loader {
     return null;
   }
 
+  @Override
   void buildCache(final ClasspathCache cache) throws IOException {
     ZipFile zipFile = null;
     try {
@@ -142,6 +144,7 @@ class JarLoader extends Loader {
     }
   }
 
+  @Override
   @Nullable
   Resource getResource(String name, boolean flag) {
     final long started = myDebugTime ? System.nanoTime():0;
@@ -197,18 +200,22 @@ class JarLoader extends Loader {
       myUrl = url;
     }
 
+    @Override
     public String getName() {
       return myEntry.getName();
     }
 
+    @Override
     public URL getURL() {
       return myUrl;
     }
 
+    @Override
     public URL getCodeSourceURL() {
       return myURL;
     }
 
+    @Override
     @Nullable
     public InputStream getInputStream() throws IOException {
       final boolean[] wasReleased = {false};
@@ -229,6 +236,7 @@ class JarLoader extends Loader {
         final ZipFile finalFile = file;
         return new FilterInputStream(inputStream) {
           private boolean myClosed = false;
+          @Override
           public void close() throws IOException {
             super.close();
             if (!myClosed) {
@@ -247,6 +255,7 @@ class JarLoader extends Loader {
       }
     }
 
+    @Override
     public int getContentLength() {
       return (int)myEntry.getSize();
     }

From 545aa80cb61d850bd9ffc517ae852cf645575494 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Wed, 27 Feb 2013 18:34:28 +0400
Subject: [PATCH 340/354] do not call filter with injected file and host tex
 trange

---
 .../codeInsight/daemon/impl/LocalInspectionsPass.java      | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/LocalInspectionsPass.java b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/LocalInspectionsPass.java
index 2277b6ddf831..ae2d8b9b5228 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/LocalInspectionsPass.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/LocalInspectionsPass.java
@@ -620,16 +620,15 @@ public class LocalInspectionsPass extends ProgressableTextEditorHighlightingPass
       TextRange hostRange = ((DocumentWindow)documentRange).injectedToHost(editable);
       int start = hostRange.getStartOffset();
       int end = hostRange.getEndOffset();
-      HighlightInfo.Builder builder = HighlightInfo.newHighlightInfo(info.type);
-      builder.range(element, start, end);
+      HighlightInfo.Builder builder = HighlightInfo.newHighlightInfo(info.type).range(element, start, end);
       if (info.description != null) {
         builder.description(info.description);
       }
       if (info.toolTip != null) {
         builder.escapedToolTip(info.toolTip);
       }
-      HighlightInfo patched = builder.create();
-      if (patched != null && (patched.startOffset != patched.endOffset || info.startOffset == info.endOffset)) {
+      HighlightInfo patched = builder.createUnconditionally();
+      if (patched.startOffset != patched.endOffset || info.startOffset == info.endOffset) {
         patched.fromInjection = true;
         registerQuickFixes(tool, descriptor, patched, emptyActionRegistered);
         outInfos.add(patched);

From 63de67fb6d830f791327b6afa00fe27495f00f56 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Wed, 27 Feb 2013 20:42:18 +0400
Subject: [PATCH 341/354] cleanup

---
 .../plugins/intelliLang/inject/CustomErrorElementFilter.java     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
index b54d59f90b07..07e1d34cf852 100644
--- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
+++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
@@ -19,7 +19,6 @@ import com.intellij.codeInsight.daemon.impl.HighlightInfo;
 import com.intellij.codeInsight.daemon.impl.HighlightInfoFilter;
 import com.intellij.codeInsight.highlighting.HighlightErrorFilter;
 import com.intellij.lang.annotation.HighlightSeverity;
-import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiErrorElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;

From ca0377afef097366d440c4a299901576558e95a0 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Thu, 28 Feb 2013 14:56:38 +0400
Subject: [PATCH 342/354] encoding review followup

---
 .../intellij/openapi/vfs/CharsetToolkit.java  | 15 +++++++------
 .../LossyEncodingInspection.java              |  6 ++---
 .../encoding/ChangeFileEncodingAction.java    | 18 +++++++--------
 .../encoding/EncodingProjectManagerImpl.java  | 22 +++++++++++--------
 .../openapi/vfs/encoding/EncodingUtil.java    | 13 +----------
 .../encoding/IncompatibleEncodingDialog.java  | 10 +--------
 .../openapi/wm/impl/status/EncodingPanel.java |  2 +-
 7 files changed, 36 insertions(+), 50 deletions(-)

diff --git a/platform/core-api/src/com/intellij/openapi/vfs/CharsetToolkit.java b/platform/core-api/src/com/intellij/openapi/vfs/CharsetToolkit.java
index 1dd76ef820c1..95ca3db56341 100644
--- a/platform/core-api/src/com/intellij/openapi/vfs/CharsetToolkit.java
+++ b/platform/core-api/src/com/intellij/openapi/vfs/CharsetToolkit.java
@@ -94,12 +94,12 @@ public class CharsetToolkit {
   public static final byte[] UTF32LE_BOM = {-1, -2, 0, 0 };
   @NonNls public static final String FILE_ENCODING_PROPERTY = "file.encoding";
 
-  @NonNls private static final Map<Charset, byte[]> CHARSET_TO_BOM = new THashMap<Charset, byte[]>(2);
+  @NonNls private static final Map<Charset, byte[]> CHARSET_TO_MANDATORY_BOM = new THashMap<Charset, byte[]>(2);
   static {
-    CHARSET_TO_BOM.put(UTF_16LE_CHARSET, UTF16LE_BOM);
-    CHARSET_TO_BOM.put(UTF_16BE_CHARSET, UTF16BE_BOM);
-    CHARSET_TO_BOM.put(UTF_32BE_CHARSET, UTF32BE_BOM);
-    CHARSET_TO_BOM.put(UTF_32LE_CHARSET, UTF32LE_BOM);
+    CHARSET_TO_MANDATORY_BOM.put(UTF_16LE_CHARSET, UTF16LE_BOM);
+    CHARSET_TO_MANDATORY_BOM.put(UTF_16BE_CHARSET, UTF16BE_BOM);
+    CHARSET_TO_MANDATORY_BOM.put(UTF_32BE_CHARSET, UTF32BE_BOM);
+    CHARSET_TO_MANDATORY_BOM.put(UTF_32LE_CHARSET, UTF32LE_BOM);
   }
 
   /**
@@ -503,12 +503,13 @@ public class CharsetToolkit {
 
   @Nullable
   public static byte[] getBom(@NotNull Charset charset) {
-    return CHARSET_TO_BOM.get(charset);
+    return CHARSET_TO_MANDATORY_BOM.get(charset);
   }
 
   // byte sequence for this encoding is allowed to be prepended with this BOM
   public static boolean canHaveBom(@NotNull Charset charset, @NotNull byte[] bom) {
-    return charset.equals(UTF8_CHARSET) && Arrays.equals(bom, UTF8_BOM) || Arrays.equals(getBom(charset), bom);
+    return charset.equals(UTF8_CHARSET) && Arrays.equals(bom, UTF8_BOM)
+           || Arrays.equals(getBom(charset), bom);
   }
 
   @Nullable
diff --git a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
index e3eb52bde61d..8e2d5144f529 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java
@@ -138,6 +138,9 @@ public class LossyEncodingInspection extends LocalInspectionTool {
                                        @NotNull String text,
                                        @NotNull Charset charset,
                                        @NotNull Project project) {
+    FileDocumentManager documentManager = FileDocumentManager.getInstance();
+    Document document = documentManager.getDocument(virtualFile);
+    if (document == null) return true;
     byte[] bytes;
     try {
       bytes = virtualFile.contentsToByteArray();
@@ -145,9 +148,6 @@ public class LossyEncodingInspection extends LocalInspectionTool {
     catch (IOException e) {
       return true;
     }
-    FileDocumentManager documentManager = FileDocumentManager.getInstance();
-    Document document = documentManager.getDocument(virtualFile);
-    if (document == null) return true;
     String separator = LoadTextUtil.detectLineSeparator(virtualFile, false);
     if (separator == null) {
       separator = documentManager.isDocumentUnsaved(document) ?
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/ChangeFileEncodingAction.java b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/ChangeFileEncodingAction.java
index d69460b4f76b..b016f51e047b 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/ChangeFileEncodingAction.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/ChangeFileEncodingAction.java
@@ -62,10 +62,7 @@ public class ChangeFileEncodingAction extends AnAction implements DumbAware {
     Document document = documentManager.getDocument(virtualFile);
     if (document == null) return false;
 
-    boolean canConvert = EncodingUtil.checkCanConvert(virtualFile) == null;
-    boolean canReload = EncodingUtil.checkCanReload(virtualFile).second == null;
-
-    return canConvert || canReload;
+    return EncodingUtil.checkCanConvert(virtualFile) == null || EncodingUtil.checkCanReload(virtualFile).second == null;
   }
 
   @Override
@@ -94,7 +91,7 @@ public class ChangeFileEncodingAction extends AnAction implements DumbAware {
     Editor editor = PlatformDataKeys.EDITOR.getData(dataContext);
     FileDocumentManager documentManager = FileDocumentManager.getInstance();
     final Document document = documentManager.getDocument(virtualFile);
-    if (!allowDirectories && !virtualFile.isDirectory() && document == null) return null;
+    if (!allowDirectories && virtualFile.isDirectory() || document == null && !virtualFile.isDirectory()) return null;
 
     final byte[] bytes;
     try {
@@ -127,9 +124,13 @@ public class ChangeFileEncodingAction extends AnAction implements DumbAware {
        return createCharsetsActionGroup(clearItemText, null, new Function<Charset, String>() {
          @Override
          public String fun(Charset charset) {
+           assert text != null : charset;
            EncodingUtil.Magic8 safeToReload = myFile.isDirectory() ? EncodingUtil.Magic8.ABSOLUTELY : EncodingUtil.isSafeToReloadIn(myFile, text, bytes, charset);
-           EncodingUtil.Magic8 safeToConvert = myFile.isDirectory() ? EncodingUtil.Magic8.ABSOLUTELY : EncodingUtil.isSafeToConvertTo(myFile, text, bytes, charset);
-           boolean enabled = safeToReload != EncodingUtil.Magic8.NO_WAY || safeToConvert != EncodingUtil.Magic8.NO_WAY;
+           boolean enabled = safeToReload != EncodingUtil.Magic8.NO_WAY;
+           if (!enabled) {
+             EncodingUtil.Magic8 safeToConvert = myFile.isDirectory() ? EncodingUtil.Magic8.ABSOLUTELY : EncodingUtil.isSafeToConvertTo(myFile, text, bytes, charset);
+             enabled = safeToConvert != EncodingUtil.Magic8.NO_WAY;
+           }
            return enabled ? "Change encoding to '"+charset.displayName()+"'" : null;
          }
        }); // no 'clear'
@@ -163,7 +164,6 @@ public class ChangeFileEncodingAction extends AnAction implements DumbAware {
 
     if (isSafeToConvert == EncodingUtil.Magic8.ABSOLUTELY && isSafeToReload == EncodingUtil.Magic8.ABSOLUTELY) {
       //change and forget
-      EncodingManager.getInstance().setEncoding(virtualFile, charset);
       undo = new Runnable() {
         @Override
         public void run() {
@@ -178,7 +178,7 @@ public class ChangeFileEncodingAction extends AnAction implements DumbAware {
       };
     }
     else {
-      IncompatibleEncodingDialog dialog = new IncompatibleEncodingDialog(document, virtualFile, bytes, charset, isSafeToReload, isSafeToConvert);
+      IncompatibleEncodingDialog dialog = new IncompatibleEncodingDialog(virtualFile, charset, isSafeToReload, isSafeToConvert);
       dialog.show();
       if (dialog.getExitCode() == IncompatibleEncodingDialog.RELOAD_EXIT_CODE) {
         undo = new Runnable() {
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingProjectManagerImpl.java b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingProjectManagerImpl.java
index 2a0fb28d006c..8536d29cb971 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingProjectManagerImpl.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingProjectManagerImpl.java
@@ -48,6 +48,7 @@ import com.intellij.util.Processor;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashMap;
 import com.intellij.util.ui.UIUtil;
+import gnu.trove.THashSet;
 import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -315,15 +316,17 @@ public class EncodingProjectManagerImpl extends EncodingProjectManager {
 
     if (!changed.isEmpty()) {
       final Processor<VirtualFile> reloadProcessor = createChangeCharsetProcessor();
-      startReloadWithProgress(new Runnable() {
+      tryStartReloadWithProgress(new Runnable() {
         @Override
         public void run() {
+          Set<VirtualFile> processed = new THashSet<VirtualFile>();
+          next:
           for (VirtualFile changedFile : changed) {
-            final Charset newCharset = newMap.get(changedFile);
-            Charset oldCharset = oldMap.get(changedFile);
-            if (!Comparing.equal(newCharset, oldCharset)) {
-              processSubFiles(changedFile, reloadProcessor);
+            for (VirtualFile processedFile : processed) {
+              if (VfsUtilCore.isAncestor(processedFile, changedFile, false)) continue next;
             }
+            processSubFiles(changedFile, reloadProcessor);
+            processed.add(changedFile);
           }
         }
       });
@@ -400,9 +403,9 @@ public class EncodingProjectManagerImpl extends EncodingProjectManager {
     }
   }
 
-  private boolean startReloadWithProgress(@NotNull final Runnable reloadAction) {
+  private boolean tryStartReloadWithProgress(@NotNull final Runnable reloadAction) {
     Boolean suppress = SUPPRESS_RELOAD.get();
-    if (suppress != null && suppress) return false;
+    if (suppress == Boolean.TRUE) return false;
     FileDocumentManager.getInstance().saveAllDocuments();  // consider all files as unmodified
     return ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
       @Override
@@ -413,7 +416,7 @@ public class EncodingProjectManagerImpl extends EncodingProjectManager {
   }
 
   private void reloadAllFilesUnder(final VirtualFile root) {
-    startReloadWithProgress(new Runnable() {
+    tryStartReloadWithProgress(new Runnable() {
       @Override
       public void run() {
         processSubFiles(root, new Processor<VirtualFile>() {
@@ -430,7 +433,8 @@ public class EncodingProjectManagerImpl extends EncodingProjectManager {
                 }
               });
             }
-            else if (file.isCharsetSet()) {
+            // for not loaded files deep under project, reset encoding to give them chance re-detect the right one later
+            else if (file.isCharsetSet() && !file.equals(root)) {
               file.setCharset(null);
             }
             return true;
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingUtil.java b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingUtil.java
index f49441917a95..302dbc45de92 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingUtil.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/EncodingUtil.java
@@ -103,18 +103,6 @@ public class EncodingUtil {
     }
   }
 
-  static boolean isSafeToChangeSilentlyTo(@NotNull VirtualFile virtualFile, @NotNull String text, @NotNull byte[] bytes, @NotNull Charset charset) {
-    String loaded = LoadTextUtil.getTextByBinaryPresentation(bytes, charset).toString();
-    boolean canReloadSilently = loaded.equals(text);
-
-    Pair<Charset, byte[]> chosen = LoadTextUtil.chooseMostlyHarmlessCharset(virtualFile.getCharset(), charset, text);
-    byte[] saved = chosen.second;
-    boolean canSaveSilently = Arrays.equals(saved, bytes);
-
-    return canReloadSilently && canSaveSilently;
-  }
-
-
   public static void saveIn(@NotNull final Document document, final Editor editor, @NotNull final VirtualFile virtualFile, @NotNull final Charset charset) {
     FileDocumentManager documentManager = FileDocumentManager.getInstance();
     documentManager.saveDocument(document);
@@ -125,6 +113,7 @@ public class EncodingUtil {
       return;
     }
 
+    // first, save the file in the new charset and then mark the file as having the correct encoding
     virtualFile.setCharset(charset);
     try {
       LoadTextUtil.write(project, virtualFile, virtualFile, document.getText(), document.getModificationStamp());
diff --git a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/IncompatibleEncodingDialog.java b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/IncompatibleEncodingDialog.java
index 4adbddcb7706..4e4adfa8977d 100644
--- a/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/IncompatibleEncodingDialog.java
+++ b/platform/platform-impl/src/com/intellij/openapi/vfs/encoding/IncompatibleEncodingDialog.java
@@ -16,7 +16,6 @@
 package com.intellij.openapi.vfs.encoding;
 
 import com.intellij.icons.AllIcons;
-import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Pair;
@@ -30,24 +29,17 @@ import java.awt.event.ActionEvent;
 import java.nio.charset.Charset;
 
 public class IncompatibleEncodingDialog extends DialogWrapper {
-
-  @NotNull private final Document document;
   @NotNull private final VirtualFile virtualFile;
-  @NotNull private final byte[] bytes;
   @NotNull private final Charset charset;
   @NotNull private final EncodingUtil.Magic8 safeToReload;
   @NotNull private final EncodingUtil.Magic8 safeToConvert;
 
-  public IncompatibleEncodingDialog(@NotNull Document document,
-                                    @NotNull VirtualFile virtualFile,
-                                    @NotNull byte[] bytes,
+  public IncompatibleEncodingDialog(@NotNull VirtualFile virtualFile,
                                     @NotNull final Charset charset,
                                     @NotNull EncodingUtil.Magic8 safeToReload,
                                     @NotNull EncodingUtil.Magic8 safeToConvert) {
     super(false);
-    this.document = document;
     this.virtualFile = virtualFile;
-    this.bytes = bytes;
     this.charset = charset;
     this.safeToReload = safeToReload;
     this.safeToConvert = safeToConvert;
diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
index eddb5d23d1b9..7b4f77d12148 100644
--- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
+++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/EncodingPanel.java
@@ -217,7 +217,7 @@ public class EncodingPanel extends EditorBasedWidget implements StatusBarWidget.
 
         String toolTip = "File Encoding" +
                          (currentCharset == null ? "" : ": "+currentCharset.displayName()) +
-                         (failReason == null ? "" : actionEnabled ? " ("+failReason+")" : " (change disabled: " + failReason + ")");
+                         (actionEnabled ? "" : " (change disabled: " + failReason + ")");
         myComponent.setToolTipText(toolTip);
         myComponent.setText(text);
 

From eaecfe022fa7d05b17b65f079b7165c16057e8f8 Mon Sep 17 00:00:00 2001
From: Alexey Kudravtsev <cdr@intellij.com>
Date: Thu, 28 Feb 2013 14:57:58 +0400
Subject: [PATCH 343/354] less memory

---
 .../lang-impl/src/com/intellij/semantic/SemServiceImpl.java   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/semantic/SemServiceImpl.java b/platform/lang-impl/src/com/intellij/semantic/SemServiceImpl.java
index 500c66260ddb..ed0fd64d44ff 100644
--- a/platform/lang-impl/src/com/intellij/semantic/SemServiceImpl.java
+++ b/platform/lang-impl/src/com/intellij/semantic/SemServiceImpl.java
@@ -104,7 +104,7 @@ public class SemServiceImpl extends SemService{
   }
 
   private static MultiMap<SemKey, SemKey> cacheKeyHierarchy(Collection<SemKey> allKeys) {
-    final MultiMap<SemKey, SemKey> result = new MultiMap<SemKey, SemKey>();
+    final MultiMap<SemKey, SemKey> result = MultiMap.createSmartList();
     ContainerUtil.process(allKeys, new Processor<SemKey>() {
       public boolean process(SemKey key) {
         result.putValue(key, key);
@@ -124,7 +124,7 @@ public class SemServiceImpl extends SemService{
   }
 
   private MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>> collectProducers() {
-    final MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>> map = new MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>>();
+    final MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>> map = MultiMap.createSmartList();
 
     final SemRegistrar registrar = new SemRegistrar() {
       public <T extends SemElement, V extends PsiElement> void registerSemElementProvider(SemKey<T> key,

From dba9eecda4553b2253d863b6d4ac901447425dd2 Mon Sep 17 00:00:00 2001
From: Anton Makeev <Anton.Makeev@jetbrains.com>
Date: Thu, 28 Feb 2013 12:17:01 +0100
Subject: [PATCH 344/354] AppCode: regression tests

---
 .../ex/GlobalInspectionContextImpl.java           | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInspection/ex/GlobalInspectionContextImpl.java b/platform/lang-impl/src/com/intellij/codeInspection/ex/GlobalInspectionContextImpl.java
index c9f570398d23..cc7c779571fb 100644
--- a/platform/lang-impl/src/com/intellij/codeInspection/ex/GlobalInspectionContextImpl.java
+++ b/platform/lang-impl/src/com/intellij/codeInspection/ex/GlobalInspectionContextImpl.java
@@ -66,6 +66,7 @@ import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
 import java.io.File;
 import java.io.IOException;
@@ -116,6 +117,8 @@ public class GlobalInspectionContextImpl extends UserDataHolderBase implements G
   private AnalysisUIOptions myUIOptions;
   @NonNls static final String LOCAL_TOOL_ATTRIBUTE = "is_local_tool";
 
+  private boolean myUseProgressIndicatorInTests = false;
+
   public GlobalInspectionContextImpl(Project project, NotNullLazyValue<ContentManager> contentManager) {
     myProject = project;
 
@@ -499,7 +502,7 @@ public class GlobalInspectionContextImpl extends UserDataHolderBase implements G
 
   public void performInspectionsWithProgress(@NotNull final AnalysisScope scope, @NotNull final InspectionManager manager) {
     final PsiManager psiManager = PsiManager.getInstance(myProject);
-    myProgressIndicator = ApplicationManager.getApplication().isUnitTestMode() ? new EmptyProgressIndicator() : ProgressManager.getInstance().getProgressIndicator();
+    myProgressIndicator = getProgressIndicator();
     //init manager in read action
     RefManagerImpl refManager = (RefManagerImpl)getRefManager();
     try {
@@ -534,6 +537,16 @@ public class GlobalInspectionContextImpl extends UserDataHolderBase implements G
     }
   }
 
+  private ProgressIndicator getProgressIndicator() {
+    return ApplicationManager.getApplication().isUnitTestMode() && !myUseProgressIndicatorInTests
+           ? new EmptyProgressIndicator() : ProgressManager.getInstance().getProgressIndicator();
+  }
+
+  @TestOnly
+  public void setUseProgressIndicatorInTests(boolean useProgressIndicatorInTests) {
+    myUseProgressIndicatorInTests = useProgressIndicatorInTests;
+  }
+
   private void runTools(@NotNull AnalysisScope scope, @NotNull final InspectionManager manager) {
     final List<Tools> globalTools = new ArrayList<Tools>();
     final List<Tools> localTools = new ArrayList<Tools>();

From d3cde18a23fe2da379a5a016b9e4345019d59955 Mon Sep 17 00:00:00 2001
From: Kirill Likhodedov <Kirill.Likhodedov@jetbrains.com>
Date: Thu, 28 Feb 2013 15:24:31 +0400
Subject: [PATCH 345/354] [git] IDEA-102084 Fix call to the correct method

Seems that it was a copy-paste error.
This code is not called however,
since there is no Repository View for Git.
---
 .../src/git4idea/changes/GitCommittedChangeListProvider.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/plugins/git4idea/src/git4idea/changes/GitCommittedChangeListProvider.java b/plugins/git4idea/src/git4idea/changes/GitCommittedChangeListProvider.java
index 932ec1432a05..cc286d7fd66a 100644
--- a/plugins/git4idea/src/git4idea/changes/GitCommittedChangeListProvider.java
+++ b/plugins/git4idea/src/git4idea/changes/GitCommittedChangeListProvider.java
@@ -133,9 +133,9 @@ public class GitCommittedChangeListProvider implements CommittedChangesProvider<
     throws VcsException {
     GitRepositoryLocation l = (GitRepositoryLocation)location;
     final Long beforeRev = settings.getChangeBeforeFilter();
-    final Long afterRev = settings.getChangeBeforeFilter();
+    final Long afterRev = settings.getChangeAfterFilter();
     final Date beforeDate = settings.getDateBeforeFilter();
-    final Date afterDate = settings.getDateBeforeFilter();
+    final Date afterDate = settings.getDateAfterFilter();
     final String author = settings.getUserFilter();
     VirtualFile root = LocalFileSystem.getInstance().findFileByIoFile(l.getRoot());
     if (root == null) {

From 51620ad2fe1ef7e5c69d72d51f9092f6a78ef2da Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 15:21:16 +0400
Subject: [PATCH 346/354] cleanup

---
 .../theoryinpractice/testng/TestNGReferenceContributor.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/plugins/testng/src/com/theoryinpractice/testng/TestNGReferenceContributor.java b/plugins/testng/src/com/theoryinpractice/testng/TestNGReferenceContributor.java
index 6895ccd94f03..840dce8de9b6 100644
--- a/plugins/testng/src/com/theoryinpractice/testng/TestNGReferenceContributor.java
+++ b/plugins/testng/src/com/theoryinpractice/testng/TestNGReferenceContributor.java
@@ -26,8 +26,6 @@ import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.codeInsight.completion.CompletionUtil;
 import com.intellij.codeInsight.lookup.LookupValueFactory;
 import com.intellij.codeInspection.InspectionProfile;
-import com.intellij.codeInspection.InspectionProfileEntry;
-import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.text.StringUtil;
@@ -248,8 +246,8 @@ public class TestNGReferenceContributor extends PsiReferenceContributor {
       List<Object> list = new ArrayList<Object>();
 
       InspectionProfile inspectionProfile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile();
-      final InspectionProfileEntry inspectionTool = inspectionProfile.getInspectionTool(DependsOnGroupsInspection.SHORT_NAME, myElement);
-      DependsOnGroupsInspection inspection = (DependsOnGroupsInspection)((LocalInspectionToolWrapper)inspectionTool).getTool();
+      DependsOnGroupsInspection inspection = (DependsOnGroupsInspection)inspectionProfile.getUnwrappedTool(
+        DependsOnGroupsInspection.SHORT_NAME, myElement);
 
       for (String groupName : inspection.groups) {
         list.add(LookupValueFactory.createLookupValue(groupName, null));

From bafc20205f0d77baf35215015e6e1b716f5a461f Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 15:24:51 +0400
Subject: [PATCH 347/354] cleanup

---
 xml/impl/src/com/intellij/xml/util/HtmlUtil.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/xml/impl/src/com/intellij/xml/util/HtmlUtil.java b/xml/impl/src/com/intellij/xml/util/HtmlUtil.java
index 91cb2bccdd03..86252c1d22f1 100644
--- a/xml/impl/src/com/intellij/xml/util/HtmlUtil.java
+++ b/xml/impl/src/com/intellij/xml/util/HtmlUtil.java
@@ -308,9 +308,8 @@ public class HtmlUtil {
 
     switch (type) {
       case XmlEntitiesInspection.UNKNOWN_TAG:
-        LocalInspectionToolWrapper wrapper = (LocalInspectionToolWrapper)profile.getInspectionTool(HtmlUnknownTagInspection.TAG_SHORT_NAME,
-                                                                                                   containingFile);
-        HtmlUnknownTagInspection unknownTagInspection = wrapper != null ? (HtmlUnknownTagInspection)wrapper.getTool() : null;
+        HtmlUnknownTagInspection unknownTagInspection = (HtmlUnknownTagInspection)profile.getUnwrappedTool(HtmlUnknownTagInspection.TAG_SHORT_NAME,
+                                                                                                           containingFile);
         if (unknownTagInspection != null) {
           return unknownTagInspection.getAdditionalEntries();
         }

From 8d12aefe5d8eadc4586cebff4031738806f11ec2 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 15:26:01 +0400
Subject: [PATCH 348/354] cleanup

---
 .../daemon/impl/analysis/XmlHighlightVisitor.java         | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/daemon/impl/analysis/XmlHighlightVisitor.java b/xml/impl/src/com/intellij/codeInsight/daemon/impl/analysis/XmlHighlightVisitor.java
index cc56168ca95a..d4860becbf13 100644
--- a/xml/impl/src/com/intellij/codeInsight/daemon/impl/analysis/XmlHighlightVisitor.java
+++ b/xml/impl/src/com/intellij/codeInsight/daemon/impl/analysis/XmlHighlightVisitor.java
@@ -26,7 +26,6 @@ import com.intellij.codeInsight.daemon.impl.quickfix.QuickFixActionRegistrarImpl
 import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.codeInsight.quickfix.UnresolvedReferenceQuickFixProvider;
 import com.intellij.codeInspection.InspectionProfile;
-import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
 import com.intellij.codeInspection.htmlInspections.RequiredAttributesInspection;
 import com.intellij.codeInspection.htmlInspections.XmlEntitiesInspection;
 import com.intellij.lang.ASTNode;
@@ -321,10 +320,9 @@ public class XmlHighlightVisitor extends XmlElementVisitor implements HighlightV
               tag, attrName, null);
           final String localizedMessage = XmlErrorMessages.message("element.doesnt.have.required.attribute", name, attrName);
           final InspectionProfile profile = InspectionProjectProfileManager.getInstance(tag.getProject()).getInspectionProfile();
-          final LocalInspectionToolWrapper toolWrapper =
-            (LocalInspectionToolWrapper)profile.getInspectionTool(RequiredAttributesInspection.SHORT_NAME, tag);
-          if (toolWrapper != null) {
-            RequiredAttributesInspection inspection = (RequiredAttributesInspection)toolWrapper.getTool();
+          RequiredAttributesInspection inspection =
+            (RequiredAttributesInspection)profile.getUnwrappedTool(RequiredAttributesInspection.SHORT_NAME, tag);
+          if (inspection != null) {
             reportOneTagProblem(
               tag,
               attrName,

From 8380366cc2e821e491beb0529b46068932196766 Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 15:26:53 +0400
Subject: [PATCH 349/354] cleanup

---
 .../codeInsight/completion/XmlTagInsertHandler.java        | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/xml/impl/src/com/intellij/codeInsight/completion/XmlTagInsertHandler.java b/xml/impl/src/com/intellij/codeInsight/completion/XmlTagInsertHandler.java
index a8ec5ee935ca..1f6b399f4b2f 100644
--- a/xml/impl/src/com/intellij/codeInsight/completion/XmlTagInsertHandler.java
+++ b/xml/impl/src/com/intellij/codeInsight/completion/XmlTagInsertHandler.java
@@ -27,12 +27,10 @@ import com.intellij.codeInsight.template.impl.MacroCallNode;
 import com.intellij.codeInsight.template.macro.CompleteMacro;
 import com.intellij.codeInsight.template.macro.CompleteSmartMacro;
 import com.intellij.codeInspection.InspectionProfile;
-import com.intellij.codeInspection.ex.LocalInspectionToolWrapper;
 import com.intellij.codeInspection.htmlInspections.RequiredAttributesInspection;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.command.WriteCommandAction;
 import com.intellij.openapi.command.undo.UndoManager;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.RangeMarker;
 import com.intellij.openapi.editor.ScrollType;
@@ -57,7 +55,6 @@ import java.util.*;
 
 public class XmlTagInsertHandler implements InsertHandler<LookupElement> {
 
-  private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.completion.XmlTagInsertHandler");
   public static final XmlTagInsertHandler INSTANCE = new XmlTagInsertHandler();
 
   public void handleInsert(InsertionContext context, LookupElement item) {
@@ -201,10 +198,8 @@ public class XmlTagInsertHandler implements InsertHandler<LookupElement> {
 
     if (tag instanceof HtmlTag) {
       final InspectionProfile profile = InspectionProjectProfileManager.getInstance(tag.getProject()).getInspectionProfile();
-      LocalInspectionToolWrapper localInspectionToolWrapper = (LocalInspectionToolWrapper) profile.getInspectionTool(
+      RequiredAttributesInspection inspection = (RequiredAttributesInspection)profile.getUnwrappedTool(
         RequiredAttributesInspection.SHORT_NAME, tag);
-      RequiredAttributesInspection inspection = localInspectionToolWrapper != null ?
-        (RequiredAttributesInspection) localInspectionToolWrapper.getTool(): null;
 
       if (inspection != null) {
         StringTokenizer tokenizer = new StringTokenizer(inspection.getAdditionalEntries(0));

From dda2c66bb364311cc46e8fa15939b6075f7efc11 Mon Sep 17 00:00:00 2001
From: Konstantin Bulenkov <kb@jetbrains.com>
Date: Thu, 28 Feb 2013 12:40:09 +0100
Subject: [PATCH 350/354] added/ modified lines color

---
 colorSchemes/src/colorSchemes/Darcula.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/colorSchemes/src/colorSchemes/Darcula.xml b/colorSchemes/src/colorSchemes/Darcula.xml
index 91971bde70d8..9f8669fcabf0 100644
--- a/colorSchemes/src/colorSchemes/Darcula.xml
+++ b/colorSchemes/src/colorSchemes/Darcula.xml
@@ -4,7 +4,7 @@
   <option name="EDITOR_FONT_SIZE" value="12" />
   <option name="EDITOR_FONT_NAME" value="Menlo" />
   <colors>
-    <option name="ADDED_LINES_COLOR" value="3f6232" />
+    <option name="ADDED_LINES_COLOR" value="295622" />
     <option name="ANNOTATIONS_COLOR" value="8b999f" />
     <option name="CARET_COLOR" value="bbbbbb" />
     <option name="CARET_ROW_COLOR" value="323232" />
@@ -29,7 +29,7 @@
     <option name="INDENT_GUIDE" value="373737" />
     <option name="LINE_NUMBERS_COLOR" value="888888" />
     <option name="METHOD_SEPARATORS_COLOR" value="4d4d4d" />
-    <option name="MODIFIED_LINES_COLOR" value="3c4b4e" />
+    <option name="MODIFIED_LINES_COLOR" value="415f69" />
     <option name="NOTIFICATION_BACKGROUND" value="5c5c42" />
     <option name="READONLY_FRAGMENT_BACKGROUND" value="" />
     <option name="RECURSIVE_CALL_ATTRIBUTES" value="574300" />

From fc5abf36669840ffd34046a46ea74cede0e7df1e Mon Sep 17 00:00:00 2001
From: Dmitry Avdeev <Dmitry.Avdeev@jetbrains.com>
Date: Thu, 28 Feb 2013 15:45:32 +0400
Subject: [PATCH 351/354] IDEA-100777 Tasks no longer Persist Context: closing
 archives

---
 .../com/intellij/tasks/context/WorkingContextManager.java  | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
index 7e565db65aa2..ab4744b2b65a 100644
--- a/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
+++ b/plugins/tasks/tasks-core/src/com/intellij/tasks/context/WorkingContextManager.java
@@ -117,8 +117,9 @@ public class WorkingContextManager {
   }
 
   private synchronized void saveContext(@Nullable String entryName, String zipPostfix, @Nullable String comment) {
+    JBZipFile archive = null;
     try {
-      JBZipFile archive = getTasksArchive(zipPostfix);
+      archive = getTasksArchive(zipPostfix);
       if (entryName == null) {
         int i = archive.getEntries().size();
         do {
@@ -133,11 +134,13 @@ public class WorkingContextManager {
       saveContext(element);
       String s = new XMLOutputter().outputString(element);
       entry.setData(s.getBytes("UTF-8"));
-      archive.close();
     }
     catch (IOException e) {
       LOG.error(e);
     }
+    finally {
+      closeArchive(archive);
+    }
   }
 
   private JBZipFile getTasksArchive(String postfix) throws IOException {

From ee52dc831998f223336a018a2fed4c1791e7f86c Mon Sep 17 00:00:00 2001
From: Sergey Evdokimov <sergey.evdokimov@jetbrains.com>
Date: Thu, 28 Feb 2013 15:46:51 +0400
Subject: [PATCH 352/354] Add option 'Ingore' to Maven -> Import -> Generated
 sources folder

---
 .../jetbrains/idea/maven/importing/MavenFoldersImporter.java   | 3 +++
 .../jetbrains/idea/maven/project/MavenImportingSettings.java   | 1 +
 2 files changed, 4 insertions(+)

diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenFoldersImporter.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenFoldersImporter.java
index 085239a00820..fc5e457217d0 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenFoldersImporter.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/importing/MavenFoldersImporter.java
@@ -237,6 +237,9 @@ public class MavenFoldersImporter {
 
         addAllSubDirsAsSources(targetDir, isTestSources);
         break;
+
+      case IGNORE:
+        break; // Ignore.
     }
   }
 
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenImportingSettings.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenImportingSettings.java
index 9c75cdb97554..12f7adeba2ba 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenImportingSettings.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenImportingSettings.java
@@ -53,6 +53,7 @@ public class MavenImportingSettings implements Cloneable {
   private List<Listener> myListeners = ContainerUtil.createLockFreeCopyOnWriteList();
 
   public enum GeneratedSourcesFolder {
+    IGNORE("Don't detect"),
     AUTODETECT("Detect automatically"),
     GENERATED_SOURCE_FOLDER("target/generated-sources"),
     SUBFOLDER("subdirectories of \"target/generated-sources\"");

From c8da931b742d18859e48b4433294d051cc3787dc Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Thu, 28 Feb 2013 15:59:30 +0400
Subject: [PATCH 353/354] the real cleanup

---
 .../intelliLang/inject/CustomErrorElementFilter.java | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
index 07e1d34cf852..5a01e38a63fd 100644
--- a/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
+++ b/plugins/IntelliLang/src/org/intellij/plugins/intelliLang/inject/CustomErrorElementFilter.java
@@ -29,12 +29,9 @@ import org.jetbrains.annotations.Nullable;
  * @author Gregory.Shrago
  */
 public class CustomErrorElementFilter extends HighlightErrorFilter implements HighlightInfoFilter {
-  public boolean shouldHighlightErrorElement(@NotNull final PsiErrorElement element) {
-    return !value(element);
-  }
 
-  public static boolean value(final PsiErrorElement psiErrorElement) {
-    return isFrankenstein(psiErrorElement.getContainingFile());
+  public boolean shouldHighlightErrorElement(@NotNull PsiErrorElement element) {
+    return !isFrankenstein(element.getContainingFile());
   }
 
   @Override
@@ -44,12 +41,11 @@ public class CustomErrorElementFilter extends HighlightErrorFilter implements Hi
     if (!isFrankenstein(file)) return true;
     int start = highlightInfo.getStartOffset();
     int end = highlightInfo.getEndOffset();
-    // the bad news are: offsets may be in host file or in injected file
-    String text = (end < file.getTextLength() ? file.getText() : file.getContext().getContainingFile().getText()).substring(start, end);
+    String text = file.getText().substring(start, end);
     return !"missingValue".equals(text);
   }
 
-  private static boolean isFrankenstein(PsiFile file) {
+  private static boolean isFrankenstein(@Nullable PsiFile file) {
     return file != null && Boolean.TRUE.equals(file.getUserData(InjectedLanguageUtil.FRANKENSTEIN_INJECTION));
   }
 }

From 02da9283e02b21aede37f97ab930f42050b0cd30 Mon Sep 17 00:00:00 2001
From: "Gregory.Shrago" <gregory.shrago@jetbrains.com>
Date: Thu, 28 Feb 2013 16:04:06 +0400
Subject: [PATCH 354/354] [anna] unify single- and multi- target navigation

---
 .../actions/GotoDeclarationAction.java        | 25 ++++++++-----------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoDeclarationAction.java b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoDeclarationAction.java
index 64231d05ce2a..0d0bfa845005 100644
--- a/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoDeclarationAction.java
+++ b/platform/lang-impl/src/com/intellij/codeInsight/navigation/actions/GotoDeclarationAction.java
@@ -92,17 +92,8 @@ public class GotoDeclarationAction extends BaseCodeInsightAction implements Code
       PsiElement navElement = element.getNavigationElement();
       navElement = TargetElementUtilBase.getInstance().getGotoDeclarationTarget(element, navElement);
 
-      if (navElement instanceof Navigatable) {
-        if (((Navigatable)navElement).canNavigate()) {
-          ((Navigatable)navElement).navigate(true);
-        }
-      }
-      else if (navElement != null) {
-        int navOffset = navElement.getTextOffset();
-        VirtualFile virtualFile = PsiUtilCore.getVirtualFile(navElement);
-        if (virtualFile != null) {
-          new OpenFileDescriptor(project, virtualFile, navOffset).navigate(true);
-        }
+      if (navElement != null) {
+        gotoTargetElement(navElement);
       }
     }
     catch (IndexNotReadyException e) {
@@ -114,10 +105,7 @@ public class GotoDeclarationAction extends BaseCodeInsightAction implements Code
     PsiElementProcessor<PsiElement> navigateProcessor = new PsiElementProcessor<PsiElement>() {
       @Override
       public boolean execute(@NotNull final PsiElement element) {
-        Navigatable navigatable = EditSourceUtil.getDescriptor(element);
-        if (navigatable != null && navigatable.canNavigate()) {
-          navigatable.navigate(true);
-        }
+        gotoTargetElement(element);
         return true;
       }
     };
@@ -128,6 +116,13 @@ public class GotoDeclarationAction extends BaseCodeInsightAction implements Code
     }
   }
 
+  private static void gotoTargetElement(PsiElement element) {
+    Navigatable navigatable = element instanceof Navigatable ? (Navigatable)element : EditSourceUtil.getDescriptor(element);
+    if (navigatable != null && navigatable.canNavigate()) {
+      navigatable.navigate(true);
+    }
+  }
+
   // returns true if processor is run or is going to be run after showing popup
   public static boolean chooseAmbiguousTarget(@NotNull Editor editor,
                                               int offset,