don't waste memory on ElementPatternCondition

platform/core-api/src/com/intellij/patterns/ElementPatternCondition.java

@@ -27,7 +27,7 @@ import java.util.List;
  * @author peter
  */
 @SuppressWarnings("ForLoopReplaceableByForEach")
-public class ElementPatternCondition<T> {
+public final class ElementPatternCondition<T> {
 
   private final InitialPatternCondition<T> myInitialCondition;
   private final List<PatternCondition<? super T>> myConditions;
@@ -37,8 +37,12 @@ public class ElementPatternCondition<T> {
     myConditions = Collections.emptyList();
   }
 
-  protected ElementPatternCondition(final ElementPatternCondition<T> original,
-                                    final PatternCondition<? super T> condition) {
+  ElementPatternCondition(InitialPatternCondition<T> initialCondition, List<PatternCondition<? super T>> conditions) {
+    myInitialCondition = initialCondition;
+    myConditions = conditions;
+  }
+
+  private ElementPatternCondition(ElementPatternCondition<T> original, PatternCondition<? super T> condition) {
     myInitialCondition = original.getInitialCondition();
     myConditions = new SmartList<PatternCondition<? super T>>(original.getConditions());
     myConditions.add(condition);

platform/core-api/src/com/intellij/patterns/ObjectPattern.java

@@ -24,24 +24,23 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
+import java.util.*;
 
 /**
  * @author peter
  */
 public abstract class ObjectPattern<T, Self extends ObjectPattern<T, Self>> implements Cloneable, ElementPattern<T> {
-  private ElementPatternCondition<T> myCondition;
+  private InitialPatternCondition<T> myInitialCondition;
+  private Object myConditions;
 
   protected ObjectPattern(@NotNull final InitialPatternCondition<T> condition) {
-    myCondition = new ElementPatternCondition<T>(condition);
+    myInitialCondition = condition;
+    myConditions = null;
   }
 
   protected ObjectPattern(final Class<T> aClass) {
-    final Condition<Object> checker = InstanceofCheckerGenerator.getInstance().getInstanceofChecker(aClass);
-    myCondition = new ElementPatternCondition<T>(new InitialPatternCondition<T>(aClass) {
+    this(new InitialPatternCondition<T>(aClass) {
+      final Condition<Object> checker = InstanceofCheckerGenerator.getInstance().getInstanceofChecker(aClass);
       public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
         return checker.value(o);
       }
@@ -49,15 +48,38 @@ public abstract class ObjectPattern<T, Self extends ObjectPattern<T, Self>> impl
   }
 
   public final boolean accepts(@Nullable Object t) {
-    return myCondition.accepts(t, new ProcessingContext());
+    return accepts(t, new ProcessingContext());
   }
 
+  @SuppressWarnings("unchecked")
   public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
-    return myCondition.accepts(o, context);
+    if (!myInitialCondition.accepts(o, context)) return false;
+    if (myConditions == null) return true;
+    if (o == null) return false;
+
+    if (myConditions instanceof PatternCondition) {
+      return ((PatternCondition)myConditions).accepts(o, context);
+    }
+
+    List<PatternCondition<T>> list = (List<PatternCondition<T>>)myConditions;
+    final int listSize = list.size();
+    //noinspection ForLoopReplaceableByForEach
+    for (int i = 0; i < listSize; i++) {
+      if (!list.get(i).accepts((T)o, context)) return false;
+    }
+    return true;
   }
 
-  public final ElementPatternCondition getCondition() {
-    return myCondition;
+  @SuppressWarnings("unchecked")
+  public final ElementPatternCondition<T> getCondition() {
+    if (myConditions == null) {
+      return new ElementPatternCondition<T>(myInitialCondition);
+    }
+    if (myConditions instanceof PatternCondition) {
+      PatternCondition<? super T> singleCondition = (PatternCondition)myConditions;
+      return new ElementPatternCondition<T>(myInitialCondition, Collections.<PatternCondition<? super T>>singletonList(singleCondition));
+    }
+    return new ElementPatternCondition<T>(myInitialCondition, (List)myConditions);
   }
 
   public Self andNot(final ElementPattern pattern) {
@@ -172,14 +194,17 @@ public abstract class ObjectPattern<T, Self extends ObjectPattern<T, Self>> impl
   }
 
   public Self with(final PatternCondition<? super T> pattern) {
-    final ElementPatternCondition<T> condition = myCondition.append(pattern);
+    final ElementPatternCondition<T> condition = getCondition().append(pattern);
     return adapt(condition);
   }
 
   private Self adapt(final ElementPatternCondition<T> condition) {
     try {
       final ObjectPattern s = (ObjectPattern)clone();
-      s.myCondition = condition;
+      s.myInitialCondition = condition.getInitialCondition();
+      List<PatternCondition<? super T>> conditions = condition.getConditions();
+      s.myConditions = conditions.isEmpty() ? null : conditions.size() == 1 ? conditions.get(0) : conditions;
+      //noinspection unchecked
       return (Self)s;
     }
     catch (CloneNotSupportedException e) {
@@ -196,7 +221,7 @@ public abstract class ObjectPattern<T, Self extends ObjectPattern<T, Self>> impl
   }
 
   public String toString() {
-    return myCondition.toString();
+    return getCondition().toString();
   }
 
   public static class Capture<T> extends ObjectPattern<T,Capture<T>> {