public MockComponentManager(@Nullable picocontainer parent,@NotNull disposable parentdisposable) {
  mypicocontainer = new Ideapicocontainer(parent) {
    private Set<Object> mydisposableComponents = new ConcurrentHashSet<Object>();

    @Override
    @Nullable
    public Object getComponentInstance(final Object componentKey) {
      final Object o = super.getComponentInstance(componentKey);
      if (o instanceof disposable && o != MockComponentManager.this) {
        if (mydisposableComponents.add(o))
          disposer.register(MockComponentManager.this,(disposable)o);
      }
      return o;
    }
  };
  mypicocontainer.registerComponentInstance(this);
  disposer.register(parentdisposable,this);
}

public static Map<SliceNode,Collection<PsiElement>> createMap() {
  return new FactoryMap<SliceNode,Collection<PsiElement>>() {
    @Override
    protected Map<SliceNode,Collection<PsiElement>> createMap() {
      return new ConcurrentHashMap<SliceNode,Collection<PsiElement>>(ContainerUtil.<SliceNode>identityStrategy());
    }

    @Override
    protected Collection<PsiElement> create(SliceNode key) {
      return new ConcurrentHashSet<PsiElement>(SliceLeafAnalyzer.LEAF_ELEMENT_EQUALITY);
    }
  };
}

@Override
public boolean addNotificationListener(@NotNull ExternalSystemTaskId taskId,@NotNull ExternalSystemTaskNotificationListener listener) {
  Set<ExternalSystemTaskId> ids = null;
  while (ids == null) {
    if (myListeners.containsKey(listener)) {
      ids = myListeners.get(listener);
    }
    else {
      ids = myListeners.putIfAbsent(listener,new ConcurrentHashSet<ExternalSystemTaskId>());
    }
  }
  return ids.add(taskId);
}

private static Set<VirtualFileListener> getSet(final String fileUrl,final Map<String,Set<VirtualFileListener>> map) {
  Set<VirtualFileListener> listeners = map.get(fileUrl);

  if (listeners == null) {
    listeners = new ConcurrentHashSet<VirtualFileListener>();
    map.put(fileUrl,listeners);
  }
  return listeners;
}

private Collection<Runnable> getCallbacks(@NotNull EventType eventType) {
  Collection<Runnable> result = myCallbacks.get(eventType);
  if (result == null) {
    Collection<Runnable> candidate = myCallbacks.putIfAbsent(eventType,result = new ConcurrentHashSet<Runnable>());
    if (candidate != null) {
      result = candidate;
    }
  }
  return result;
}

@Override
public boolean addNotificationListener(@Nonnull ExternalSystemTaskId taskId,@Nonnull ExternalSystemTaskNotificationListener listener) {
  Set<ExternalSystemTaskId> ids = null;
  while (ids == null) {
    if (myListeners.containsKey(listener)) {
      ids = myListeners.get(listener);
    }
    else {
      ids = myListeners.putIfAbsent(listener,new ConcurrentHashSet<ExternalSystemTaskId>());
    }
  }
  return ids.add(taskId);
}

private static Set<VirtualFileListener> getSet(final String fileUrl,listeners);
  }
  return listeners;
}

private Collection<Runnable> getCallbacks(@Nonnull EventType eventType) {
  Collection<Runnable> result = myCallbacks.get(eventType);
  if (result == null) {
    Collection<Runnable> candidate = myCallbacks.putIfAbsent(eventType,result = new ConcurrentHashSet<Runnable>());
    if (candidate != null) {
      result = candidate;
    }
  }
  return result;
}

public static Map<SliceNode,Collection<PsiElement>>(ContainerUtil.<SliceNode>identityStrategy());
    }

    @Override
    protected Collection<PsiElement> create(SliceNode key) {
      return new ConcurrentHashSet<PsiElement>(SliceLeafAnalyzer.LEAF_ELEMENT_EQUALITY);
    }
  };
}

private static CompileContext createContextwrapper(final CompileContext delegate) {
  final ClassLoader loader = delegate.getClass().getClassLoader();
  final UserDataHolderBase localDataHolder = new UserDataHolderBase();
  final Set<Object> deletedKeysSet = new ConcurrentHashSet<Object>();
  final Class<UserDataHolder> dataHolderInterface = UserDataHolder.class;
  final Class<MessageHandler> messageHandlerInterface = MessageHandler.class;
  return (CompileContext)Proxy.newProxyInstance(loader,new Class[]{CompileContext.class},new InvocationHandler() {
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
      final Class<?> declaringClass = method.getDeclaringClass();
      if (dataHolderInterface.equals(declaringClass)) {
        final Object firstArgument = args[0];
        if (!(firstArgument instanceof GlobalContextKey)) {
          final boolean isWriteOperation = args.length == 2 /*&& void.class.equals(method.getReturnType())*/;
          if (isWriteOperation) {
            if (args[1] == null) {
              deletedKeysSet.add(firstArgument);
            }
            else {
              deletedKeysSet.remove(firstArgument);
            }
          }
          else {
            if (deletedKeysSet.contains(firstArgument)) {
              return null;
            }
          }
          final Object result = method.invoke(localDataHolder,args);
          if (isWriteOperation || result != null) {
            return result;
          }
        }
      }
      else if (messageHandlerInterface.equals(declaringClass)) {
        final BuildMessage msg = (BuildMessage)args[0];
        if (msg.getKind() == BuildMessage.Kind.ERROR) {
          Utils.ERRORS_DETECTED_KEY.set(localDataHolder,Boolean.TRUE);
        }
      }
      try {
        return method.invoke(delegate,args);
      }
      catch (InvocationTargetException e) {
        final Throwable targetEx = e.getTargetException();
        if (targetEx instanceof ProjectBuildException) {
          throw targetEx;
        }
        throw e;
      }
    }
  });
}

public JarFileSystemImpl(MessageBus bus) {
  boolean nocopy = SystemProperties.getBooleanProperty("idea.jars.nocopy",!SystemInfo.isWindows);
  myNocopyJarPaths = nocopy ? null : new ConcurrentHashSet<String>(FileUtil.PATH_HASHING_STRATEGY);

  bus.connect().subscribe(VirtualFileManager.VFS_CHANGES,new BulkFileListener.Adapter() {
    @Override
    public void after(@NotNull final List<? extends VFileEvent> events) {
      final List<VirtualFile> rootsToRefresh = new ArrayList<VirtualFile>();

      for (VFileEvent event : events) {
        if (event.getFileSystem() instanceof LocalFileSystem) {
          String path = event.getPath();

          String[] jarPaths;
          synchronized (LOCK) {
            jarPaths = jarPathsCache;
            if (jarPaths == null) {
              jarPathsCache = jarPaths = ArrayUtil.toStringArray(myHandlers.keySet());
            }
          }

          for (String jarPath : jarPaths) {
            final String jarFile = jarPath.substring(0,jarPath.length() - JAR_SEParaTOR.length());
            if (FileUtil.startsWith(jarFile,path)) {
              VirtualFile jarRoottoRefresh = markDirty(jarPath);
              if (jarRoottoRefresh != null) {
                rootsToRefresh.add(jarRoottoRefresh);
              }
            }
          }
        }
      }

      if (!rootsToRefresh.isEmpty()) {
        final Application app = ApplicationManager.getApplication();
        Runnable runnable = new Runnable() {
          @Override
          public void run() {
            if (app.isdisposed()) return;
            for (VirtualFile root : rootsToRefresh) {
              if (root.isValid()) {
                ((NewVirtualFile)root).markDirtyRecursively();
              }
            }
            RefreshQueue.getInstance().refresh(false,true,null,rootsToRefresh);
          }
        };
        if (app.isUnitTestMode()) {
          runnable.run();
        }
        else {
          app.invokelater(runnable,ModalityState.NON_MODAL);
        }
      }
    }
  });
}

static void processConstructorUsages(final PsiMethod constructor,final SearchScope searchScope,final Processor<PsiReference> consumer,final SearchRequestCollector collector,final boolean searchGppCalls,final boolean includeOverloads) {
  if (!constructor.isConstructor()) return;

  final PsiClass clazz = constructor.getContainingClass();
  if (clazz == null) return;

  SearchScope onlyGroovy = GroovyScopeUtil.restrictScopetoGroovyFiles(searchScope,GroovyScopeUtil.getEffectiveScope(constructor));
  Set<PsiClass> processed = collector.getSearchSession().getUserData(LIteraLLY_CONSTRUCTED_CLASSES);
  if (processed == null) {
    collector.getSearchSession().putUserData(LIteraLLY_CONSTRUCTED_CLASSES,processed = new ConcurrentHashSet<PsiClass>());
  }
  if (!processed.add(clazz)) return;

  if (clazz.isEnum() && clazz instanceof GroovyPsiElement) {
    for (PsiField field : clazz.getFields()) {
      if (field instanceof GrEnumConstant) {
        final PsiReference ref = field.getReference();
        if (ref != null && ref.isReferenceto(constructor)) {
          if (!consumer.process(ref)) return;
        }
      }
    }
  }

  final LiteralConstructorSearcher literalProcessor = new LiteralConstructorSearcher(constructor,consumer,includeOverloads);

  final Processor<GrNewExpression> newExpressionProcessor = new Processor<GrNewExpression>() {
    @Override
    public boolean process(GrNewExpression grNewExpression) {
      final PsiMethod resolvedConstructor = grNewExpression.resolveMethod();
      if (includeOverloads || constructor.getManager().areElementsEquivalent(resolvedConstructor,constructor)) {
        return consumer.process(grNewExpression.getReferenceElement());
      }
      return true;
    }
  };

  processGroovyClassUsages(clazz,searchScope,collector,searchGppCalls,newExpressionProcessor,literalProcessor);

  //this()
  if (clazz instanceof GrTypeDeFinition) {
    if (!processConstructors(constructor,clazz,true)) {
      return;
    }
  }
  //super()
  DirectClassInheritoRSSearch.search(clazz,onlyGroovy).forEach(new ReadActionProcessor<PsiClass>() {
    @Override
    public boolean processInReadAction(PsiClass inheritor) {
      if (inheritor instanceof GrTypeDeFinition) {
        if (!processConstructors(constructor,inheritor,false)) return false;
      }
      return true;
    }
  });
}