Merge branch 'db/method-chains-completion'

# Conflicts:
#	jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
#	jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java
#	jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java

diff --cc java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java
Simple merge

diff --cc java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java
Simple merge

diff --cc java/java-impl/src/com/intellij/codeInsight/completion/JavaCompletionSorting.java
Simple merge

diff --cc jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
index 9e6fae62dbae73c2638c01c5375e7f65dae9a4fe,c2573bb5af6ccf03af9908ca4c4a0c47c238cff3..0cda59fda43945be33e81d7fa675980f3bc3ae7d
--- 1/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
--- 2/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
@@@ -27,56 -30,86 +29,91 @@@ import java.util.*
  
  public class BackwardReferenceIndexUtil {
    static void registerFile(String filePath,
-                            Collection<? extends JavacRef> refs,
+                            TObjectIntHashMap<? extends JavacRef> refs,
                             List<JavacDef> defs,
                             final BackwardReferenceIndexWriter writer) {
 -    final int fileId = writer.enumeratePath(filePath);
 -    int funExprId = 0;
  
 -    final Map<LightRef, Void> definitions = new THashMap<>(defs.size());
 -    final Map<LightRef, Collection<LightRef>> backwardHierarchyMap = new THashMap<>();
 -    final Map<SignatureData, Collection<LightRef>> signatureData = new THashMap<>();
 +    try {
 +      final int fileId = writer.enumeratePath(filePath);
 +      int funExprId = 0;
  
 -    final AnonymousClassEnumerator anonymousClassEnumerator = new AnonymousClassEnumerator();
 +      final Map<LightRef, Void> definitions = new HashMap<>(defs.size());
 +      final Map<LightRef, Collection<LightRef>> backwardHierarchyMap = new HashMap<>();
++      final Map<SignatureData, Collection<LightRef>> signatureData = new THashMap<>();
+ 
 -    for (JavacDef def : defs) {
 -      if (def instanceof JavacDef.JavacClassDef) {
 -        JavacRef.JavacClass sym = (JavacRef.JavacClass)def.getDefinedElement();
++      final AnonymousClassEnumerator anonymousClassEnumerator = new AnonymousClassEnumerator();
  
 -        final LightRef.LightClassHierarchyElementDef aClass;
 -        if (sym.isAnonymous()) {
 -          final JavacRef[] classes = ((JavacDef.JavacClassDef)def).getSuperClasses();
 -          aClass = anonymousClassEnumerator.addAnonymous(sym.getName(), writer.asClassUsage(classes[0]));
 -        } else {
 -          aClass = writer.asClassUsage(sym);
 -        }
 -        definitions.put(aClass, null);
 +      for (JavacDef def : defs) {
 +        if (def instanceof JavacDef.JavacClassDef) {
 +          JavacRef.JavacClass sym = (JavacRef.JavacClass)def.getDefinedElement();
-           final LightRef.JavaLightClassRef aClass = writer.asClassUsage(sym);
+ 
 -        final JavacRef[] superClasses = ((JavacDef.JavacClassDef)def).getSuperClasses();
 -        for (JavacRef superClass : superClasses) {
 -          LightRef.JavaLightClassRef superClassRef = writer.asClassUsage(superClass);
++          final LightRef.LightClassHierarchyElementDef aClass;
++          if (sym.isAnonymous()) {
++            final JavacRef[] classes = ((JavacDef.JavacClassDef)def).getSuperClasses();
++            aClass = anonymousClassEnumerator.addAnonymous(sym.getName(), writer.asClassUsage(classes[0]));
++          } else {
++            aClass = writer.asClassUsage(sym);
++          }
 +          definitions.put(aClass, null);
  
 -          backwardHierarchyMap.computeIfAbsent(superClassRef, k -> new SmartList<>()).add(aClass);
 -        }
 -      }
 -      else if (def instanceof JavacDef.JavacFunExprDef) {
 -        final LightRef.JavaLightClassRef functionalType = writer.asClassUsage(def.getDefinedElement());
 -        int id = funExprId++;
 -        LightRef.JavaLightFunExprDef result = new LightRef.JavaLightFunExprDef(id);
 -        definitions.put(result, null);
 +          final JavacRef[] superClasses = ((JavacDef.JavacClassDef)def).getSuperClasses();
 +          for (JavacRef superClass : superClasses) {
 +            LightRef.JavaLightClassRef superClassRef = writer.asClassUsage(superClass);
  
-             Collection<LightRef> children = backwardHierarchyMap.get(superClassRef);
-             if (children == null) {
-               backwardHierarchyMap.put(superClassRef, children = new SmartList<>());
-             }
-             children.add(aClass);
 -        ContainerUtil.getOrCreate(backwardHierarchyMap, functionalType,
 -                                  (Factory<Collection<LightRef>>)() -> new SmartList<>()).add(result);
 -      }
 -      else if (def instanceof JavacDef.JavacMemberDef) {
 -        final LightRef ref = writer.enumerateNames(def.getDefinedElement(), name -> anonymousClassEnumerator.getLightRefIfAnonymous(name));
 -        final LightRef.JavaLightClassRef returnType = writer.asClassUsage(((JavacDef.JavacMemberDef)def).getReturnType());
 -        if (ref != null && returnType != null) {
 -          final SignatureData data = new SignatureData(returnType.getName(), ((JavacDef.JavacMemberDef)def).isStatic());
 -          signatureData.computeIfAbsent(data, element -> new SmartList<>()).add(ref);
++            backwardHierarchyMap.computeIfAbsent(superClassRef, k -> new SmartList<>()).add(aClass);
 +          }
          }
 -      }
 -    }
 +        else if (def instanceof JavacDef.JavacFunExprDef) {
 +          final LightRef.JavaLightClassRef functionalType = writer.asClassUsage(def.getDefinedElement());
 +          int id = funExprId++;
 +          LightRef.JavaLightFunExprDef result = new LightRef.JavaLightFunExprDef(id);
 +          definitions.put(result, null);
  
 -    Map<LightRef, Integer> convertedRefs = new THashMap<>();
 -    refs.forEachEntry((ref, count) -> {
 -      final LightRef lightRef = writer.enumerateNames(ref, name -> anonymousClassEnumerator.getLightRefIfAnonymous(name));
 -      if (lightRef != null) {
 -        convertedRefs.put(lightRef, count);
 +          ContainerUtil.getOrCreate(backwardHierarchyMap, functionalType,
 +                                    (Factory<Collection<LightRef>>)() -> new SmartList<>()).add(result);
 +        }
++        else if (def instanceof JavacDef.JavacMemberDef) {
++          final LightRef ref = writer.enumerateNames(def.getDefinedElement(), name -> anonymousClassEnumerator.getLightRefIfAnonymous(name));
++          final LightRef.JavaLightClassRef returnType = writer.asClassUsage(((JavacDef.JavacMemberDef)def).getReturnType());
++          if (ref != null && returnType != null) {
++            final SignatureData data = new SignatureData(returnType.getName(), ((JavacDef.JavacMemberDef)def).isStatic());
++            signatureData.computeIfAbsent(data, element -> new SmartList<>()).add(ref);
++          }
++        }
        }
 -      return true;
 -    });
  
-       Map<LightRef, Void> convertedRefs = new HashMap<>(refs.size());
-       for (JavacRef ref : refs) {
-         LightRef key = writer.enumerateNames(ref);
-         if (key != null) {
-           convertedRefs.put(key, null);
 -    writer.writeData(fileId, new CompiledFileData(backwardHierarchyMap, convertedRefs, definitions, signatureData));
++      Map<LightRef, Integer> convertedRefs = new THashMap<>();
++      refs.forEachEntry((ref, count) -> {
++        final LightRef lightRef = writer.enumerateNames(ref, name -> anonymousClassEnumerator.getLightRefIfAnonymous(name));
++        if (lightRef != null) {
++          convertedRefs.put(lightRef, count);
 +        }
-       }
++        return true;
++      });
 +      writer.writeData(fileId, new CompiledFileData(backwardHierarchyMap, convertedRefs, definitions));
 +    }
 +    catch (IOException e) {
 +      writer.setRebuildCause(e);
 +    }
    }
+ 
+   private static class AnonymousClassEnumerator {
+     private THashMap<String, LightRef.LightClassHierarchyElementDef> myAnonymousName2Id = null;
+ 
+     private LightRef.JavaLightAnonymousClassRef addAnonymous(String internalName,
+                                                              LightRef.JavaLightClassRef base) {
+       if (myAnonymousName2Id == null) {
+         myAnonymousName2Id = new THashMap<>();
+       }
+       final int anonymousIdx = myAnonymousName2Id.size();
+       myAnonymousName2Id.put(internalName, base);
+       return new LightRef.JavaLightAnonymousClassRef(anonymousIdx);
+     }
+ 
+     private Integer getLightRefIfAnonymous(String className) {
+       if (myAnonymousName2Id == null) return null;
+       final LightRef.LightClassHierarchyElementDef ref = myAnonymousName2Id.get(className);
+       return ref == null ? null : ref.getName();
+     }
+   }
  }

diff --cc jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java
index 5cc44a7cce74a283db0889e35fc7e4a5674fbefe,aa5e4999f23e57a16f5984dc6a99c226d25eb828..976daca9d946b4fc0e7bbbee741c890fc86323fb
--- 1/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java
--- 2/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java
@@@ -15,7 -15,7 +15,8 @@@
   */
  package org.jetbrains.jps.backwardRefs;
  
+ import com.intellij.util.Function;
 +import com.intellij.openapi.util.io.FileUtil;
  import com.intellij.util.SystemProperties;
  import com.intellij.util.indexing.InvertedIndex;
  import org.jetbrains.annotations.NotNull;
@@@ -131,7 -128,7 +132,7 @@@ public class BackwardReferenceIndexWrit
    }
  
    @Nullable
-   LightRef enumerateNames(JavacRef ref) throws IOException {
 -  LightRef enumerateNames(JavacRef ref, Function<String, Integer> ownerIdReplacer) {
++  LightRef enumerateNames(JavacRef ref, Function<String, Integer> ownerIdReplacer) throws IOException {
      NameEnumerator nameEnumerator = myIndex.getByteSeqEum();
      if (ref instanceof JavacRef.JavacClass) {
        if (!isPrivate(ref) && !((JavacRef.JavacClass)ref).isAnonymous()) {

diff --cc jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java
index a6019dd6bfcce9c73552d5b1f775f8d2f23b7d22,939528db0cb3953ec730c552f06a52a6a41433a0..376f50ff8ba76d44f7cc425cc68bb2e9f56803f6
--- 1/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java
--- 2/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java
@@@ -84,9 -82,9 +84,9 @@@ public class CompilerBackwardReferenceI
        };
  
        myIndices = new HashMap<>();
-       for (IndexExtension<LightRef, ?, CompiledFileData> indexExtension : CompilerIndices.getIndices()) {
+       for (IndexExtension<?, ?, CompiledFileData> indexExtension : CompilerIndices.getIndices()) {
          //noinspection unchecked
 -        myIndices.put(indexExtension.getName(), new CompilerMapReduceIndex(indexExtension, myIndicesDir));
 +        myIndices.put(indexExtension.getName(), new CompilerMapReduceIndex(indexExtension, myIndicesDir, readOnly));
        }
  
        myNameEnumerator = new NameEnumerator(new File(myIndicesDir, NAME_ENUM_TAB));

diff --cc jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java
index c1e3ebcd2461423ce75015fa592eb270d818109c,528cbfdac169f460d85bfecb8d128878ab499bbd..25f3b814e610fae07a07a63c20269dbcf23715b7
--- 1/jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java
--- 2/jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java
+++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java
@@@ -20,8 -19,7 +20,7 @@@ import org.jetbrains.jps.backwardRefs.B
  import org.jetbrains.jps.builders.BuildTargetType;
  import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
  import org.jetbrains.jps.builders.java.ResourcesTargetType;
- import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFilesIndicesBuilder;
 -import org.jetbrains.jps.backwardRefs.BackwardReferenceIndexBuilder;
 +import org.jetbrains.jps.incremental.dependencies.DependencyResolvingBuilder;
  import org.jetbrains.jps.incremental.instrumentation.NotNullInstrumentingBuilder;
  import org.jetbrains.jps.incremental.instrumentation.RmiStubsGenerator;
  import org.jetbrains.jps.incremental.java.JavaBuilder;
@@@ -48,14 -46,10 +47,13 @@@ public class JavaBuilderService extend
    @NotNull
    @Override
    public List<? extends ModuleLevelBuilder> createModuleLevelBuilders() {
 -    return Arrays.asList(new JavaBuilder(SharedThreadPool.getInstance()),
 -                         new NotNullInstrumentingBuilder(),
 -                         new RmiStubsGenerator(),
 -                         new BackwardReferenceIndexBuilder());
 +    return Arrays.asList(
 +      new JavaBuilder(SharedThreadPool.getInstance()),
 +      new NotNullInstrumentingBuilder(),
 +      new RmiStubsGenerator(),
-       new ClassFilesIndicesBuilder(),
 +      new DependencyResolvingBuilder(),
 +      new BackwardReferenceIndexBuilder()
 +    );
    }
  
    @NotNull

diff --cc jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTestBase.kt
Simple merge

diff --cc platform/util/resources/misc/registry.properties
Simple merge

diff --cc resources/src/META-INF/IdeaPlugin.xml
Simple merge

diff --cc resources/src/idea/RichPlatformPlugin.xml
Simple merge