MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

use compiler indices in method chains completion (draft)

Browse Source
This commit is contained in:
Dmitry Batkovich
2017-04-03 15:53:48 +03:00
parent 4800fda14b
commit ce262d41ff
47 changed files with 321 additions and 1809 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java
+4
View File
@@ -138,6 +138,10 @@ class CompilerReferenceReader {
return result[0];
}
public CompilerBackwardReferenceIndex getIndex() {
return myIndex;
}
static boolean exists(Project project) {
File buildDir = BuildManager.getInstance().getProjectSystemDirectory(project);
if (buildDir == null || CompilerBackwardReferenceIndex.versionDiffers(buildDir)) {
java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceServiceImpl.java
+60 -1
View File
@@ -20,12 +20,16 @@ import com.intellij.compiler.CompilerReferenceService;
import com.intellij.compiler.backwardRefs.view.CompilerReferenceFindUsagesTestInfo;
import com.intellij.compiler.backwardRefs.view.CompilerReferenceHierarchyTestInfo;
import com.intellij.compiler.backwardRefs.view.DirtyScopeTestInfo;
import com.intellij.compiler.classFilesIndex.impl.UsageIndexValue;
import com.intellij.compiler.server.BuildManager;
import com.intellij.compiler.server.BuildManagerListener;
import com.intellij.lang.injection.InjectedLanguageManager;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ReadAction;
import com.intellij.openapi.compiler.*;
import com.intellij.openapi.compiler.CompilationStatusListener;
import com.intellij.openapi.compiler.CompileContext;
import com.intellij.openapi.compiler.CompileScope;
import com.intellij.openapi.compiler.CompilerManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileTypes.FileType;
@@ -47,6 +51,7 @@ import com.intellij.psi.util.CachedValueProvider;
import com.intellij.psi.util.CachedValuesManager;
import com.intellij.psi.util.PsiModificationTracker;
import com.intellij.psi.util.PsiUtilCore;
import com.intellij.util.SmartList;
import com.intellij.util.containers.ConcurrentFactoryMap;
import com.intellij.util.indexing.FileBasedIndex;
import com.intellij.util.indexing.StorageException;
@@ -57,6 +62,8 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.TestOnly;
import org.jetbrains.jps.backwardRefs.LightRef;
import org.jetbrains.jps.backwardRefs.SignatureData;
import org.jetbrains.jps.backwardRefs.index.CompilerIndices;
import java.io.IOException;
import java.util.*;
@@ -160,6 +167,58 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple
closeReaderIfNeed(false);
}
@Override
public TreeSet<UsageIndexValue> getMethods(String name) {
try {
myReadDataLock.lock();
if (myReader == null) return null;
JavaLightUsageAdapter adapter = new JavaLightUsageAdapter();
try {
final int type = adapter.findMembersForReturnType(name, myReader.getNameEnumerator());
return Stream.of(new SignatureData(type, true), new SignatureData(type, false)).flatMap(sd -> {
try {
List<LightRef> refs = new SmartList<>();
myReader.getIndex().get(CompilerIndices.BACK_MEMBER_SIGN).getData(sd).forEach((id, _refs) -> {
refs.addAll(_refs);
return true;
});
return refs.stream().map(x -> new Object() {
LightRef myRef = x;
SignatureData mySignatureData = sd;
});
}
catch (StorageException e) {
throw new RuntimeException(e);
}
}).map(ref -> {
int[] res = new int[]{0};
try {
myReader.getIndex().get(CompilerIndices.BACK_USAGES).getData(ref.myRef).forEach((id, c) -> {
res[0] += c;
return true;
});
}
catch (StorageException e) {
throw new RuntimeException(e);
}
if (!(ref.myRef instanceof LightRef.JavaLightMethodRef)) return null;
return new UsageIndexValue(adapter.denumerate((LightRef.JavaLightMethodRef)ref.myRef,
ref.mySignatureData,
myReader.getNameEnumerator()),
res[0]);
}).filter(Objects::nonNull).collect(Collectors.toCollection(TreeSet::new));
}
catch (Exception e) {
e.printStackTrace();
}
return null;//TODO
} finally {
myReadDataLock.unlock();
}
}
@Nullable
@Override
public GlobalSearchScope getScopeWithoutCodeReferences(@NotNull PsiElement element) {
java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java
+15
View File
@@ -15,6 +15,7 @@
*/
package com.intellij.compiler.backwardRefs;
import com.intellij.compiler.classFilesIndex.impl.MethodIncompleteSignature;
import com.intellij.ide.highlighter.JavaClassFileType;
import com.intellij.ide.highlighter.JavaFileType;
import com.intellij.openapi.application.ReadAction;
@@ -32,6 +33,7 @@ import gnu.trove.TIntHashSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.backwardRefs.LightRef;
import org.jetbrains.jps.backwardRefs.NameEnumerator;
import org.jetbrains.jps.backwardRefs.SignatureData;
import java.io.IOException;
import java.util.ArrayList;
@@ -164,9 +166,22 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter {
return ((PsiClass) candidate).isInheritor((PsiClass) baseClass, false);
}
public int findMembersForReturnType(@NotNull String returnType, @NotNull NameEnumerator names) throws IOException {
return names.tryEnumerate(returnType);
}
private static boolean mayBeVisibleOutsideOwnerFile(@NotNull PsiElement element) {
if (!(element instanceof PsiModifierListOwner)) return true;
if (((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.PRIVATE)) return false;
return true;
}
public MethodIncompleteSignature denumerate(LightRef.JavaLightMethodRef ref,
SignatureData data,
NameEnumerator enumerator) {
return new MethodIncompleteSignature(enumerator.getName(ref.getOwner().getName()),
enumerator.getName(data.getRawReturnType()),
enumerator.getName(ref.getName()),
data.isStatic());
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexConfigure.java
-38
View File
@@ -1,38 +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 com.intellij.compiler.classFilesIndex.api.index;
import com.intellij.openapi.project.Project;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexerFactory;
/**
* @author Dmitry Batkovich
*/
public abstract class ClassFilesIndexConfigure<K, V> {
public abstract String getIndexCanonicalName();
public abstract int getIndexVersion();
public abstract Class<? extends ClassFileIndexerFactory> getIndexerBuilderClass();
public abstract ClassFilesIndexReaderBase<K, V> createIndexReader(final Project project);
public void prepareToIndexing(final Project project) {
ClassFilesIndexReaderBase.checkIndexAndRecreateIfNeed(project, getIndexVersion(), getIndexCanonicalName());
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexFeature.java
-76
View File
@@ -1,76 +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 com.intellij.compiler.classFilesIndex.api.index;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexConfigure;
import com.intellij.openapi.util.registry.Registry;
import com.intellij.openapi.util.registry.RegistryValue;
import org.jetbrains.annotations.NotNull;
import java.util.Collection;
import java.util.Collections;
/**
* @author Dmitry Batkovich
*/
@SuppressWarnings("unchecked")
public enum ClassFilesIndexFeature {
METHOD_CHAINS_COMPLETION("completion.enable.relevant.method.chain.suggestions", MethodsUsageIndexConfigure.INSTANCE);
@NotNull
private final String myKey;
@NotNull
private final Collection<? extends ClassFilesIndexConfigure> myRequiredIndicesConfigures;
ClassFilesIndexFeature(@NotNull final String key,
@NotNull final Collection<? extends ClassFilesIndexConfigure> requiredIndicesConfigures) {
myKey = key;
myRequiredIndicesConfigures = requiredIndicesConfigures;
}
ClassFilesIndexFeature(@NotNull final String key, @NotNull final ClassFilesIndexConfigure requiredConfigure) {
this(key, Collections.<ClassFilesIndexConfigure>singleton(requiredConfigure));
}
public RegistryValue getRegistryValue() {
return Registry.get(myKey);
}
@NotNull
public String getKey() {
return myKey;
}
/**
* is feature enabled by registry key
*/
public boolean isEnabled() {
return Registry.is(myKey);
}
public void enable() {
getRegistryValue().setValue(true);
}
public void disable() {
getRegistryValue().setValue(false);
}
@NotNull
public Collection<? extends ClassFilesIndexConfigure> getRequiredIndicesConfigures() {
return myRequiredIndicesConfigures;
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexFeaturesHolder.java
-178
View File
@@ -1,178 +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 com.intellij.compiler.classFilesIndex.api.index;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexConfigure;
import com.intellij.openapi.compiler.CompileContext;
import com.intellij.openapi.compiler.CompileTask;
import com.intellij.openapi.compiler.CompilerManager;
import com.intellij.openapi.components.AbstractProjectComponent;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.registry.RegistryValue;
import com.intellij.openapi.util.registry.RegistryValueListener;
import com.intellij.util.Processor;
import org.jetbrains.annotations.Nullable;
import java.util.HashMap;
import java.util.Map;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexFeaturesHolder extends AbstractProjectComponent {
private final Map<ClassFilesIndexConfigure, ClassFilesIndexReaderBase> myEnabledIndexReaders =
new HashMap<>();
private final Map<ClassFilesIndexFeature, FeatureState> myEnabledFeatures = new HashMap<>();
public static ClassFilesIndexFeaturesHolder getInstance(final Project project) {
return project.getComponent(ClassFilesIndexFeaturesHolder.class);
}
protected ClassFilesIndexFeaturesHolder(final Project project) {
super(project);
}
@Override
public final void projectOpened() {
for (final ClassFilesIndexFeature feature : ClassFilesIndexFeature.values()) {
final RegistryValue registryValue = feature.getRegistryValue();
registryValue.addListener(new RegistryValueListener.Adapter() {
@Override
public void afterValueChanged(final RegistryValue rawValue) {
if (!rawValue.asBoolean() && myEnabledFeatures.containsKey(feature)) {
disposeFeature(feature);
}
}
}, myProject);
}
final CompilerManager compilerManager = CompilerManager.getInstance(myProject);
compilerManager.addBeforeTask(new CompileTask() {
@Override
public boolean execute(final CompileContext context) {
close();
return true;
}
});
}
public synchronized boolean enableFeatureIfNeed(final ClassFilesIndexFeature feature) {
if (!feature.isEnabled()) {
return false;
}
FeatureState state = myEnabledFeatures.get(feature);
if (state == null) {
state = initializeFeature(feature);
}
return state == FeatureState.AVAILABLE;
}
public synchronized void visitConfigures(final ConfigureVisitor visitor) {
for (final ClassFilesIndexConfigure configure : myEnabledIndexReaders.keySet()) {
visitor.visit(configure, true);
}
for (final ClassFilesIndexFeature feature : ClassFilesIndexFeature.values()) {
if (feature.isEnabled() && !myEnabledFeatures.containsKey(feature)) {
for (final ClassFilesIndexConfigure configure : feature.getRequiredIndicesConfigures()) {
if (!myEnabledIndexReaders.containsKey(configure)) {
visitor.visit(configure, false);
}
}
}
}
}
private synchronized void disposeFeature(final ClassFilesIndexFeature featureToRemove) {
for (final ClassFilesIndexConfigure requiredConfigure : featureToRemove.getRequiredIndicesConfigures()) {
boolean needClose = true;
for (final ClassFilesIndexFeature enabledFeature : myEnabledFeatures.keySet()) {
if (!enabledFeature.equals(featureToRemove) && enabledFeature.getRequiredIndicesConfigures().contains(requiredConfigure)) {
needClose = false;
break;
}
}
if (needClose) {
final ClassFilesIndexReaderBase readerToClose = myEnabledIndexReaders.remove(requiredConfigure);
readerToClose.close();
}
}
myEnabledFeatures.remove(featureToRemove);
}
private synchronized FeatureState initializeFeature(final ClassFilesIndexFeature feature) {
if (myEnabledFeatures.containsKey(feature)) {
throw new IllegalStateException(String.format("feature %s already contains", feature.getKey()));
}
final Map<ClassFilesIndexConfigure, ClassFilesIndexReaderBase> newIndices =
new HashMap<>();
FeatureState newFeatureState = FeatureState.AVAILABLE;
for (final ClassFilesIndexConfigure requiredConfigure : feature.getRequiredIndicesConfigures()) {
boolean isIndexAlreadyLoaded = false;
for (final ClassFilesIndexFeature enabledFeature : myEnabledFeatures.keySet()) {
if (enabledFeature.getRequiredIndicesConfigures().contains(requiredConfigure)) {
isIndexAlreadyLoaded = true;
break;
}
}
if (!isIndexAlreadyLoaded) {
final ClassFilesIndexReaderBase reader = requiredConfigure.createIndexReader(myProject);
newIndices.put(requiredConfigure, reader);
if (reader.isEmpty()) {
newFeatureState = FeatureState.NOT_AVAILABLE;
}
}
}
myEnabledIndexReaders.putAll(newIndices);
myEnabledFeatures.put(feature, newFeatureState);
return newFeatureState;
}
private synchronized void close() {
for (final ClassFilesIndexReaderBase reader : myEnabledIndexReaders.values()) {
reader.close();
}
myEnabledIndexReaders.clear();
myEnabledFeatures.clear();
}
@Override
public void projectClosed() {
close();
}
/**
* try to find index with corresponding class only in currently enabled indexes
*/
@Nullable
@SuppressWarnings("unchecked")
public <T extends ClassFilesIndexReaderBase> T getAvailableIndexReader(final Class<T> tClass) {
final String indexReaderClassName = tClass.getCanonicalName();
for (final ClassFilesIndexReaderBase reader : myEnabledIndexReaders.values()) {
if (reader.getClass().getCanonicalName().equals(indexReaderClassName)) {
return (T)reader;
}
}
throw new RuntimeException(String.format("index reader for class %s not found", indexReaderClassName));
}
public Project getProject() {
return myProject;
}
private enum FeatureState {
AVAILABLE,
NOT_AVAILABLE
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexReaderBase.java
-165
View File
@@ -1,165 +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 com.intellij.compiler.classFilesIndex.api.index;
import com.intellij.compiler.server.BuildManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.KeyDescriptor;
import com.intellij.util.io.PersistentHashMap;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import org.jetbrains.jps.classFilesIndex.indexer.api.IndexState;
import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageBase;
import org.jetbrains.jps.incremental.storage.BuildDataManager;
import java.io.File;
import java.io.IOException;
/**
* @author Dmitry Batkovich
*/
public abstract class ClassFilesIndexReaderBase<K, V> {
public static final String VERSION_FILE_NAME = "version";
private final static Logger LOG = Logger.getInstance(ClassFilesIndexReaderBase.class);
@Nullable
protected final ClassFilesIndexStorageReader<K, V> myIndex;
@Nullable
protected final Mappings myMappings;
public static boolean checkIndexAndRecreateIfNeed(final Project project, final int currentVersion, final String canonicalIndexName) {
final File projectBuildSystemDirectory = BuildManager.getInstance().getProjectSystemDirectory(project);
assert projectBuildSystemDirectory != null;
final File versionFile = new File(ClassFilesIndexStorageBase.getIndexDir(canonicalIndexName, projectBuildSystemDirectory), VERSION_FILE_NAME);
final File indexDir = ClassFilesIndexStorageBase.getIndexDir(canonicalIndexName, projectBuildSystemDirectory);
if (versionFile.exists() &&
!versionDiffers(projectBuildSystemDirectory, canonicalIndexName, currentVersion) &&
IndexState.load(indexDir) == IndexState.EXIST) {
return true;
}
else {
recreateIndex(canonicalIndexName, currentVersion, projectBuildSystemDirectory, indexDir);
return false;
}
}
@SuppressWarnings("ConstantConditions")
protected ClassFilesIndexReaderBase(final KeyDescriptor<K> keyDescriptor,
final DataExternalizer<V> valueExternalizer,
final String canonicalIndexName,
final int indexVersion,
final Project project) {
if (checkIndexAndRecreateIfNeed(project, indexVersion, canonicalIndexName)) {
ClassFilesIndexStorageReader<K, V> index = null;
IOException exception = null;
final File projectBuildSystemDirectory = BuildManager.getInstance().getProjectSystemDirectory(project);
final File indexDir = ClassFilesIndexStorageBase.getIndexDir(canonicalIndexName, projectBuildSystemDirectory);
try {
index = new ClassFilesIndexStorageReader<>(indexDir, keyDescriptor, valueExternalizer);
}
catch (final IOException e) {
exception = e;
PersistentHashMap.deleteFilesStartingWith(ClassFilesIndexStorageBase.getIndexFile(indexDir));
}
if (exception != null) {
recreateIndex(canonicalIndexName, indexVersion, projectBuildSystemDirectory, indexDir);
myIndex = null;
myMappings = null;
}
else {
myIndex = index;
try {
myMappings = new Mappings(BuildDataManager.getMappingsRoot(projectBuildSystemDirectory),false);
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
}
else {
myIndex = null;
myMappings = null;
}
}
private static void recreateIndex(final String canonicalIndexName,
final int indexVersion,
final File projectBuildSystemDirectory,
final File indexDir) {
if (indexDir.exists()) {
FileUtil.delete(indexDir);
}
try {
FileUtil.writeToFile(new File(ClassFilesIndexStorageBase.getIndexDir(canonicalIndexName, projectBuildSystemDirectory), VERSION_FILE_NAME),
String.valueOf(indexVersion));
}
catch (final IOException e) {
throw new RuntimeException(e);
}
IndexState.NOT_EXIST.save(indexDir);
}
public boolean isEmpty() {
return myIndex == null;
}
public final void close() {
if (myIndex != null) {
try {
myIndex.close();
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
if (myMappings != null) {
myMappings.close();
}
}
public final void delete() {
try {
if (myIndex != null) {
myIndex.delete();
}
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
private static File getVersionFile(final File projectBuildSystemDirectory, final String canonicalIndexName) {
return new File(ClassFilesIndexStorageBase.getIndexDir(canonicalIndexName, projectBuildSystemDirectory), VERSION_FILE_NAME);
}
private static boolean versionDiffers(final File projectBuildSystemDirectory, final String canonicalIndexName, final int currentVersion) {
final File versionFile = getVersionFile(projectBuildSystemDirectory, canonicalIndexName);
if (!versionFile.exists()) {
return true;
}
try {
return Integer.parseInt(FileUtil.loadFile(versionFile)) != currentVersion;
}
catch (final IOException e) {
LOG.error("error while reading version file " + versionFile.getAbsolutePath());
return true;
}
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexStorageReader.java
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2000-2014 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.compiler.classFilesIndex.api.index;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.KeyDescriptor;
import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageBase;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexStorageReader<K, V> extends ClassFilesIndexStorageBase<K, V> {
public ClassFilesIndexStorageReader(final File indexDir,
final KeyDescriptor<K> keyDescriptor,
final DataExternalizer<V> valueExternalizer) throws IOException {
super(indexDir, keyDescriptor, valueExternalizer);
}
public Collection<V> getData(final K key) {
return myCache.get(key).getValues();
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ClassFilesIndexerBuilderParametersProvider.java
-56
View File
@@ -1,56 +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 com.intellij.compiler.classFilesIndex.api.index;
import com.intellij.compiler.server.BuildProcessParametersProvider;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.Processor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFilesIndicesBuilder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexerBuilderParametersProvider extends BuildProcessParametersProvider {
private final ClassFilesIndexFeaturesHolder myIndicesHolder;
protected ClassFilesIndexerBuilderParametersProvider(final ClassFilesIndexFeaturesHolder indicesHolder) {
myIndicesHolder = indicesHolder;
}
@NotNull
@Override
public List<String> getVMArguments() {
final List<String> args = new ArrayList<>();
myIndicesHolder.visitConfigures(new ConfigureVisitor() {
@Override
public void visit(ClassFilesIndexConfigure<?, ?> configure, boolean isAvailable) {
final String className = configure.getIndexerBuilderClass().getCanonicalName();
args.add(className);
if (!isAvailable) {
configure.prepareToIndexing(myIndicesHolder.getProject());
}
}
});
return args.size() != 0
? Collections.singletonList("-D" + ClassFilesIndicesBuilder.PROPERTY_NAME + "=" + StringUtil.join(args, ";"))
: Collections.<String>emptyList();
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/api/index/ConfigureVisitor.java
-25
View File
@@ -1,25 +0,0 @@
/*
* Copyright 2000-2014 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.compiler.classFilesIndex.api.index;
/**
* @author Dmitry Batkovich
*/
public interface ConfigureVisitor {
void visit(ClassFilesIndexConfigure<?, ?> configure, boolean isAvailable);
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/CachedRelevantStaticMethodSearcher.java
+3 -5
View File
@@ -15,13 +15,11 @@
*/
package com.intellij.compiler.classFilesIndex.chainsSearch;
import com.intellij.compiler.CompilerReferenceService;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextRelevantStaticMethod;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexReader;
import com.intellij.compiler.classFilesIndex.impl.UsageIndexValue;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.SmartList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -34,11 +32,11 @@ import java.util.*;
*/
public class CachedRelevantStaticMethodSearcher {
private final HashMap<MethodIncompleteSignature, PsiMethod> myCachedResolveResults = new HashMap<>();
private final MethodsUsageIndexReader myIndexReader;
private final CompilerReferenceService myIndexReader;
private final ChainCompletionContext myCompletionContext;
public CachedRelevantStaticMethodSearcher(final ChainCompletionContext completionContext) {
myIndexReader = MethodsUsageIndexReader.getInstance(completionContext.getProject());
myIndexReader = CompilerReferenceService.getInstance(completionContext.getProject());
myCompletionContext = completionContext;
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/ChainsSearcher.java
+4 -5
View File
@@ -15,10 +15,10 @@
*/
package com.intellij.compiler.classFilesIndex.chainsSearch;
import com.intellij.compiler.CompilerReferenceService;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.TargetType;
import com.intellij.compiler.classFilesIndex.impl.MethodIncompleteSignature;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexReader;
import com.intellij.compiler.classFilesIndex.impl.UsageIndexValue;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProgressManager;
@@ -27,7 +27,6 @@ import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiManager;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -50,7 +49,7 @@ public final class ChainsSearcher {
final Set<String> contextQNames,
final int maxResultSize,
final ChainCompletionContext context,
final MethodsUsageIndexReader methodsUsageIndexReader) {
final CompilerReferenceService methodsUsageIndexReader) {
final SearchInitializer initializer = createInitializer(targetType, context.getExcludedQNames(), methodsUsageIndexReader, context);
if (initializer == null) {
return Collections.emptyList();
@@ -67,14 +66,14 @@ public final class ChainsSearcher {
@Nullable
private static SearchInitializer createInitializer(final TargetType target,
final Set<String> excludedParamsTypesQNames,
final MethodsUsageIndexReader methodsUsageIndexReader,
final CompilerReferenceService methodsUsageIndexReader,
final ChainCompletionContext context) {
final SortedSet<UsageIndexValue> methods = methodsUsageIndexReader.getMethods(target.getClassQName());
return new SearchInitializer(methods, target.getClassQName(), excludedParamsTypesQNames, context);
}
@NotNull
private static List<MethodsChain> search(final MethodsUsageIndexReader indexReader,
private static List<MethodsChain> search(final CompilerReferenceService indexReader,
final SearchInitializer initializer,
final Set<String> toSet,
final int pathMaximalLength,
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/completion/MethodsChainsCompletionContributor.java
+3 -15
View File
@@ -2,15 +2,12 @@ package com.intellij.compiler.classFilesIndex.chainsSearch.completion;
import com.intellij.codeInsight.completion.*;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeature;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeaturesHolder;
import com.intellij.compiler.CompilerReferenceService;
import com.intellij.compiler.classFilesIndex.chainsSearch.*;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ChainCompletionContext;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.ContextUtil;
import com.intellij.compiler.classFilesIndex.chainsSearch.context.TargetType;
import com.intellij.compiler.classFilesIndex.impl.MethodsUsageIndexReader;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.module.ModuleUtilCore;
import com.intellij.openapi.project.Project;
import com.intellij.patterns.ElementPattern;
import com.intellij.psi.*;
@@ -39,15 +36,6 @@ public class MethodsChainsCompletionContributor extends CompletionContributor {
private final static int MAX_CHAIN_SIZE = 4;
private final static int FILTER_RATIO = 10;
@Override
public void fillCompletionVariants(@NotNull final CompletionParameters parameters, @NotNull final CompletionResultSet result) {
if (parameters.getInvocationCount() >= INVOCATIONS_THRESHOLD &&
ClassFilesIndexFeaturesHolder.getInstance(parameters.getPosition().getProject())
.enableFeatureIfNeed(ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION)) {
super.fillCompletionVariants(parameters, result);
}
}
@SuppressWarnings("unchecked")
public MethodsChainsCompletionContributor() {
final ElementPattern<PsiElement> pattern = or(patternForMethodParameter(), patternForVariableAssignment());
@@ -95,7 +83,7 @@ public class MethodsChainsCompletionContributor extends CompletionContributor {
final Set<String> contextRelevantTypes,
final ChainCompletionContext completionContext) {
final Project project = completionContext.getProject();
final MethodsUsageIndexReader methodsUsageIndexReader = MethodsUsageIndexReader.getInstance(project);
final CompilerReferenceService methodsUsageIndexReader = CompilerReferenceService.getInstance(project);
final List<MethodsChain> searchResult =
searchChains(target, contextRelevantTypes, MAX_SEARCH_RESULT_SIZE, MAX_CHAIN_SIZE, completionContext, methodsUsageIndexReader);
if (searchResult.size() < MAX_SEARCH_RESULT_SIZE) {
@@ -207,7 +195,7 @@ public class MethodsChainsCompletionContributor extends CompletionContributor {
final int maxResultSize,
final int maxChainSize,
final ChainCompletionContext context,
final MethodsUsageIndexReader methodsUsageIndexReader) {
final CompilerReferenceService methodsUsageIndexReader) {
return ChainsSearcher.search(maxChainSize, target, contextVarsQNames, maxResultSize, context, methodsUsageIndexReader);
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/completion/lookup/WeightableChainLookupElement.java
+8
View File
@@ -15,9 +15,11 @@
*/
package com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup;
import com.intellij.codeInsight.lookup.LookupElementPresentation;
import com.intellij.compiler.classFilesIndex.chainsSearch.ChainRelevance;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.codeInsight.lookup.LookupElementDecorator;
import com.intellij.ui.JBColor;
import org.jetbrains.annotations.NotNull;
/**
@@ -34,4 +36,10 @@ public final class WeightableChainLookupElement extends LookupElementDecorator<L
public ChainRelevance getChainRelevance() {
return myChainRelevance;
}
@Override
public void renderElement(LookupElementPresentation presentation) {
presentation.setItemTextForeground(JBColor.GREEN);
super.renderElement(presentation);
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/chainsSearch/context/MethodIncompleteSignatureResolver.java
+1 -2
View File
@@ -21,7 +21,6 @@ import com.intellij.util.containers.FactoryMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import com.intellij.compiler.classFilesIndex.impl.MethodIncompleteSignature;
import org.jetbrains.jps.classFilesIndex.AsmUtil;
import java.util.*;
@@ -52,7 +51,7 @@ final class MethodIncompleteSignatureResolver {
if (MethodIncompleteSignature.CONSTRUCTOR_METHOD_NAME.equals(signature.getName())) {
return PsiMethod.EMPTY_ARRAY;
}
final PsiClass aClass = javaPsiFacade.findClass(AsmUtil.getQualifiedClassName(signature.getOwner()), scope);
final PsiClass aClass = javaPsiFacade.findClass(signature.getOwner(), scope);
if (aClass == null) {
return PsiMethod.EMPTY_ARRAY;
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/impl/MethodsUsageIndexConfigure.java
-54
View File
@@ -1,54 +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 com.intellij.compiler.classFilesIndex.impl;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexConfigure;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexReaderBase;
import com.intellij.openapi.project.Project;
import com.intellij.util.io.PersistentHashMapValueStorage;
import gnu.trove.TObjectIntHashMap;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexerFactory;
import org.jetbrains.jps.classFilesIndex.indexer.impl.EnumeratedMethodIncompleteSignature;
import org.jetbrains.jps.classFilesIndex.indexer.impl.MethodsUsageIndexerFactory;
import org.jetbrains.jps.classFilesIndex.indexer.impl.MethodsUsageIndexer;
/**
* @author Dmitry Batkovich
*/
public class MethodsUsageIndexConfigure extends ClassFilesIndexConfigure<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> {
public static final MethodsUsageIndexConfigure INSTANCE = new MethodsUsageIndexConfigure();
@Override
public String getIndexCanonicalName() {
return MethodsUsageIndexer.METHODS_USAGE_INDEX_CANONICAL_NAME;
}
@Override
public int getIndexVersion() {
return 1 + (PersistentHashMapValueStorage.COMPRESSION_ENABLED ? 0xFF : 0);
}
@Override
public Class<? extends ClassFileIndexerFactory> getIndexerBuilderClass() {
return MethodsUsageIndexerFactory.class;
}
@Override
public ClassFilesIndexReaderBase<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> createIndexReader(final Project project) {
return new MethodsUsageIndexReader(project, getIndexCanonicalName(), getIndexVersion());
}
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/impl/MethodsUsageIndexReader.java
-84
View File
@@ -1,84 +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 com.intellij.compiler.classFilesIndex.impl;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeaturesHolder;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexReaderBase;
import com.intellij.openapi.project.Project;
import com.intellij.util.io.EnumeratorIntegerDescriptor;
import com.intellij.util.io.EnumeratorStringDescriptor;
import gnu.trove.TObjectIntHashMap;
import gnu.trove.TObjectIntProcedure;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.classFilesIndex.TObjectIntHashMapExternalizer;
import org.jetbrains.jps.classFilesIndex.indexer.impl.EnumeratedMethodIncompleteSignature;
import java.util.Collection;
import java.util.TreeSet;
/**
* @author Dmitry Batkovich <dmitry.batkovich@jetbrains.com>
*/
public class MethodsUsageIndexReader extends ClassFilesIndexReaderBase<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> {
public static MethodsUsageIndexReader getInstance(final Project project) {
final MethodsUsageIndexReader instance =
ClassFilesIndexFeaturesHolder.getInstance(project).getAvailableIndexReader(MethodsUsageIndexReader.class);
if (instance == null) {
throw new RuntimeException("couldn't get instance");
}
return instance;
}
public MethodsUsageIndexReader(final Project project, final String canonicalIndexName, final int version) {
//noinspection ConstantConditions
super(EnumeratorIntegerDescriptor.INSTANCE,
new TObjectIntHashMapExternalizer<>(EnumeratedMethodIncompleteSignature.createDataExternalizer()),
canonicalIndexName, version, project);
}
@NotNull
public TreeSet<UsageIndexValue> getMethods(final String key) {
assert myIndex != null;
assert myMappings != null;
final Collection<TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> unReducedValues = myIndex.getData(myMappings.getName(key.replace('.', '/')));
final TObjectIntHashMap<MethodIncompleteSignature> rawValues = new TObjectIntHashMap<>();
for (final TObjectIntHashMap<EnumeratedMethodIncompleteSignature> unReducedValue : unReducedValues) {
unReducedValue.forEachEntry(new TObjectIntProcedure<EnumeratedMethodIncompleteSignature>() {
@Override
public boolean execute(final EnumeratedMethodIncompleteSignature sign, final int occurrences) {
final MethodIncompleteSignature denumerated = MethodIncompleteSignature.denumerated(sign, key, myMappings);
if (!rawValues.adjustValue(denumerated, occurrences)) {
rawValues.put(denumerated, occurrences);
}
return true;
}
});
}
final TreeSet<UsageIndexValue> values = new TreeSet<>();
rawValues.forEachEntry(new TObjectIntProcedure<MethodIncompleteSignature>() {
@Override
public boolean execute(final MethodIncompleteSignature sign, final int occurrences) {
values.add(new UsageIndexValue(sign, occurrences));
return true;
}
});
return values;
}
}
java/java-indexing-impl/src/com/intellij/compiler/CompilerReferenceService.java
+6
View File
@@ -15,6 +15,7 @@
*/
package com.intellij.compiler;
import com.intellij.compiler.classFilesIndex.impl.UsageIndexValue;
import com.intellij.openapi.components.AbstractProjectComponent;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.project.Project;
@@ -26,6 +27,8 @@ import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.TreeSet;
/**
* The service is intended to provide an information about class/method/field usages or classes hierarchy that is obtained on compilation time.
* It means that this service should not affect any find usages result when initial project is not compiled or project language is not support
@@ -39,6 +42,9 @@ public abstract class CompilerReferenceService extends AbstractProjectComponent
super(project);
}
//TODO
public abstract TreeSet<UsageIndexValue> getMethods(String name);
public static CompilerReferenceService getInstance(@NotNull Project project) {
return project.getComponent(CompilerReferenceService.class);
}
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/impl/MethodIncompleteSignature.java → java/java-indexing-impl/src/com/intellij/compiler/classFilesIndex/impl/MethodIncompleteSignature.java
+4 -10
View File
@@ -16,11 +16,6 @@
package com.intellij.compiler.classFilesIndex.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import org.jetbrains.jps.classFilesIndex.AsmUtil;
import org.jetbrains.jps.classFilesIndex.indexer.impl.EnumeratedMethodIncompleteSignature;
import java.util.Comparator;
/**
* @author Dmitry Batkovich
@@ -36,17 +31,16 @@ public class MethodIncompleteSignature {
private final String myName;
private final boolean myStatic;
private MethodIncompleteSignature(@NotNull final String owner, @NotNull final String returnType, @NotNull final String name, final boolean aStatic) {
public MethodIncompleteSignature(@NotNull final String owner,
@NotNull final String returnType,
@NotNull final String name,
final boolean aStatic) {
myOwner = owner;
myReturnType = returnType;
myName = name;
myStatic = aStatic;
}
public static MethodIncompleteSignature denumerated(final EnumeratedMethodIncompleteSignature sign, final String returnType, final Mappings mappings) {
return new MethodIncompleteSignature(AsmUtil.getQualifiedClassName(mappings.valueOf(sign.getOwner())), returnType, mappings.valueOf(sign.getName()), sign.isStatic());
}
@NotNull
public String getOwner() {
return myOwner;
java/compiler/impl/src/com/intellij/compiler/classFilesIndex/impl/UsageIndexValue.java → java/java-indexing-impl/src/com/intellij/compiler/classFilesIndex/impl/UsageIndexValue.java
+1 -3
View File
@@ -1,5 +1,5 @@
/*
* Copyright 2000-2013 JetBrains s.r.o.
* Copyright 2000-2017 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.intellij.compiler.classFilesIndex.impl;
import org.jetbrains.annotations.NotNull;
import java.util.Comparator;
/**
* @author Dmitry Batkovich
*/
java/java-tests/testSrc/com/intellij/codeInsight/completion/MethodChainsCompletionTest.java
+4 -5
View File
@@ -17,7 +17,6 @@ package com.intellij.codeInsight.completion;
import com.intellij.JavaTestUtil;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeature;
import com.intellij.compiler.classFilesIndex.chainsSearch.ChainRelevance;
import com.intellij.compiler.classFilesIndex.chainsSearch.completion.MethodsChainsCompletionContributor;
import com.intellij.compiler.classFilesIndex.chainsSearch.completion.lookup.ChainCompletionMethodCallLookupElement;
@@ -42,12 +41,12 @@ public class MethodChainsCompletionTest extends AbstractCompilerAwareTest {
protected void setUp() throws Exception {
super.setUp();
installCompiler();
ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION.enable();
//ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION.enable();
}
@Override
protected void tearDown() throws Exception {
ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION.disable();
//ClassFilesIndexFeature.METHOD_CHAINS_COMPLETION.disable();
super.tearDown();
}
@@ -213,8 +212,8 @@ public class MethodChainsCompletionTest extends AbstractCompilerAwareTest {
final int notMatchedStringVars,
final WeightableChainLookupElement actualLookupElement) {
assertLookupElementStringEquals(actualLookupElement, lookupText);
assertChainRelevanceEquals(actualLookupElement.getChainRelevance(), lastMethodWeight, chainSize, notMatchedStringVars,
unreachableParametersCount);
//assertChainRelevanceEquals(actualLookupElement.getChainRelevance(), lastMethodWeight, chainSize, notMatchedStringVars,
// unreachableParametersCount);
}
private static void assertLookupElementStringEquals(final LookupElement lookupElement, final String lookupText) {
jps/jps-builders-6/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java
+6
View File
@@ -246,6 +246,12 @@ final class JavacReferenceCollectorListener implements TaskListener {
return JavacRef.JavacElementRefBase.fromElement(element, myNameTableCache);
}
@Nullable
JavacRef.JavacElementRefBase asJavacRef(TypeMirror typeMirror) {
final Element element = getTypeUtility().asElement(typeMirror);
return element == null ? null : JavacRef.JavacElementRefBase.fromElement(element, myNameTableCache);
}
Element getReferencedElement(Tree tree) {
return myTreeHelper.getReferencedElement(tree);
}
jps/jps-builders-6/src/org/jetbrains/jps/javac/ast/JavacTreeRefScanner.java
+23 -8
View File
@@ -20,9 +20,7 @@ import com.sun.source.util.TreeScanner;
import org.jetbrains.jps.javac.ast.api.JavacDef;
import org.jetbrains.jps.javac.ast.api.JavacRef;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.*;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import java.util.EnumSet;
@@ -73,7 +71,14 @@ class JavacTreeRefScanner extends TreeScanner<Tree, JavacReferenceCollectorListe
public Tree visitVariable(VariableTree node, JavacReferenceCollectorListener.ReferenceCollector refCollector) {
final Element element = refCollector.getReferencedElement(node);
if (element != null && element.getKind() == ElementKind.FIELD) {
refCollector.sinkReference(refCollector.asJavacRef(element));
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(element);
if (ref != null) {
refCollector.sinkReference(ref);
final JavacRef.JavacElementRefBase returnType = refCollector.asJavacRef(element.asType());
if (returnType != null) {
refCollector.sinkDeclaration(new JavacDef.JavacMemberDef(ref, returnType, isStatic(element)));
}
}
}
return super.visitVariable(node, refCollector);
}
@@ -91,12 +96,18 @@ class JavacTreeRefScanner extends TreeScanner<Tree, JavacReferenceCollectorListe
public Tree visitMethod(MethodTree node, JavacReferenceCollectorListener.ReferenceCollector refCollector) {
final Element element = refCollector.getReferencedElement(node);
if (element != null) {
refCollector.sinkReference(refCollector.asJavacRef(element));
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(element);
if (ref != null) {
refCollector.sinkReference(ref);
final JavacRef.JavacElementRefBase returnType = refCollector.asJavacRef(((ExecutableElement)element).getReturnType());
if (returnType != null) {
refCollector.sinkDeclaration(new JavacDef.JavacMemberDef(ref, returnType, isStatic(element)));
}
}
}
return super.visitMethod(node, refCollector);
}
@Override
public Tree visitClass(ClassTree node, JavacReferenceCollectorListener.ReferenceCollector refCollector) {
TypeElement element = (TypeElement)refCollector.getReferencedElement(node);
@@ -107,7 +118,7 @@ class JavacTreeRefScanner extends TreeScanner<Tree, JavacReferenceCollectorListe
final JavacRef[] supers;
if (superclass != refCollector.getTypeUtility().getNoType(TypeKind.NONE)) {
supers = new JavacRef[interfaces.size() + 1];
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(refCollector.getTypeUtility().asElement(superclass));
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(superclass);
if (ref == null) return null;
supers[interfaces.size()] = ref;
@@ -117,7 +128,7 @@ class JavacTreeRefScanner extends TreeScanner<Tree, JavacReferenceCollectorListe
int i = 0;
for (TypeMirror anInterface : interfaces) {
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(refCollector.getTypeUtility().asElement(anInterface));
final JavacRef.JavacElementRefBase ref = refCollector.asJavacRef(anInterface);
if (ref == null) return null;
supers[i++] = ref;
}
@@ -137,4 +148,8 @@ class JavacTreeRefScanner extends TreeScanner<Tree, JavacReferenceCollectorListe
return new JavacTreeRefScanner();
}
}
private static boolean isStatic(Element element) {
return element.getModifiers().contains(Modifier.STATIC);
}
}
jps/jps-builders-6/src/org/jetbrains/jps/javac/ast/api/JavacDef.java
+19
View File
@@ -48,4 +48,23 @@ public abstract class JavacDef {
return myClasses;
}
}
public static class JavacMemberDef extends JavacDef {
private final JavacRef myRawReturnType;
private final boolean myStatic;
public JavacMemberDef(JavacRef element, JavacRef rawReturnType, boolean isStatic) {
super(element);
myRawReturnType = rawReturnType;
myStatic = isStatic;
}
public JavacRef getReturnType() {
return myRawReturnType;
}
public boolean isStatic() {
return myStatic;
}
}
}
jps/jps-builders-6/src/org/jetbrains/jps/javac/ast/api/JavacRef.java
+1 -1
View File
@@ -161,7 +161,7 @@ public interface JavacRef {
else if (element instanceof ExecutableElement) {
return new JavacElementMethodImpl(element, nameTableCache);
}
else if (element == null || element.getKind() == ElementKind.OTHER) {
else if (element == null || element.getKind() == ElementKind.OTHER || element.getKind() == ElementKind.TYPE_PARAMETER) {
// javac reserved symbol kind (e.g: com.sun.tools.javac.comp.Resolve.ResolveError)
return null;
}
jps/jps-builders/src/META-INF/services/org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexerFactory
-1
View File
@@ -1 +0,0 @@
org.jetbrains.jps.classFilesIndex.indexer.impl.MethodsUsageIndexerFactory
jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexUtil.java
+13 -4
View File
@@ -25,7 +25,6 @@ import org.jetbrains.jps.javac.ast.api.JavacDef;
import org.jetbrains.jps.javac.ast.api.JavacRef;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -37,8 +36,9 @@ public class BackwardReferenceIndexUtil {
final int fileId = writer.enumeratePath(filePath);
int funExprId = 0;
final Map<LightRef, Void> definitions = new HashMap<>(defs.size());
final Map<LightRef, Collection<LightRef>> backwardHierarchyMap = new HashMap<>();
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<>();
final AnonymousClassEnumerator anonymousClassEnumerator = new AnonymousClassEnumerator();
@@ -71,6 +71,14 @@ public class BackwardReferenceIndexUtil {
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);
}
}
}
Map<LightRef, Integer> convertedRefs = new THashMap<>();
@@ -81,7 +89,8 @@ public class BackwardReferenceIndexUtil {
}
return true;
});
writer.writeData(fileId, new CompiledFileData(backwardHierarchyMap, convertedRefs, definitions));
writer.writeData(fileId, new CompiledFileData(backwardHierarchyMap, convertedRefs, definitions, signatureData));
}
private static class AnonymousClassEnumerator {
jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java
+1 -1
View File
@@ -82,7 +82,7 @@ public class CompilerBackwardReferenceIndex {
};
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));
}
jps/jps-builders/src/org/jetbrains/jps/backwardRefs/SignatureData.java
+50
View File
@@ -0,0 +1,50 @@
/*
* Copyright 2000-2017 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.jps.backwardRefs;
public class SignatureData {
private final int myRawReturnType;
private final boolean myStatic;
public SignatureData(int type, boolean aStatic) {
myRawReturnType = type;
myStatic = aStatic;
}
public int getRawReturnType() {
return myRawReturnType;
}
public boolean isStatic() {
return myStatic;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SignatureData data = (SignatureData)o;
return myRawReturnType == data.myRawReturnType && myStatic == data.myStatic;
}
@Override
public int hashCode() {
int result = myRawReturnType;
result = 31 * result + (myStatic ? 1 : 0);
return result;
}
}
jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompiledFileData.java
+10 -1
View File
@@ -17,6 +17,7 @@ package org.jetbrains.jps.backwardRefs.index;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.backwardRefs.LightRef;
import org.jetbrains.jps.backwardRefs.SignatureData;
import java.util.Collection;
import java.util.Map;
@@ -25,13 +26,16 @@ public class CompiledFileData {
private final Map<LightRef, Collection<LightRef>> myBackwardHierarchyMap;
private final Map<LightRef, Integer> myReferences;
private final Map<LightRef, Void> myDefinitions;
private final Map<SignatureData, Collection<LightRef>> mySignatureData;
public CompiledFileData(@NotNull Map<LightRef, Collection<LightRef>> backwardHierarchyMap,
@NotNull Map<LightRef, Integer> references,
@NotNull Map<LightRef, Void> definitions) {
@NotNull Map<LightRef, Void> definitions,
@NotNull Map<SignatureData, Collection<LightRef>> signatureData) {
myBackwardHierarchyMap = backwardHierarchyMap;
myReferences = references;
myDefinitions = definitions;
mySignatureData = signatureData;
}
@NotNull
@@ -48,4 +52,9 @@ public class CompiledFileData {
public Map<LightRef, Void> getDefinitions() {
return myDefinitions;
}
@NotNull
public Map<SignatureData, Collection<LightRef>> getSignatureData() {
return mySignatureData;
}
}
jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerIndices.java
+85 -48
View File
@@ -15,9 +15,7 @@
*/
package org.jetbrains.jps.backwardRefs.index;
import com.intellij.openapi.util.ThrowableComputable;
import com.intellij.util.ThrowableConsumer;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.openapi.util.io.DataInputOutputUtilRt;
import com.intellij.util.indexing.DataIndexer;
import com.intellij.util.indexing.ID;
import com.intellij.util.indexing.IndexExtension;
@@ -28,13 +26,14 @@ import com.intellij.util.io.VoidDataExternalizer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.backwardRefs.LightRef;
import org.jetbrains.jps.backwardRefs.LightRefDescriptor;
import org.jetbrains.jps.backwardRefs.SignatureData;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
public class CompilerIndices {
//TODO manage version separately
@@ -43,9 +42,13 @@ public class CompilerIndices {
public final static ID<LightRef, Integer> BACK_USAGES = ID.create("back.refs");
public final static ID<LightRef, Collection<LightRef>> BACK_HIERARCHY = ID.create("back.hierarchy");
public final static ID<LightRef, Void> BACK_CLASS_DEF = ID.create("back.class.def");
public final static ID<SignatureData, Collection<LightRef>> BACK_MEMBER_SIGN = ID.create("back.member.sign");
public static List<IndexExtension<LightRef, ?, CompiledFileData>> getIndices() {
return ContainerUtil.list(createBackwardClassDefinitionExtension(), createBackwardUsagesExtension(), createBackwardHierarchyExtension());
public static List<IndexExtension<?, ?, CompiledFileData>> getIndices() {
return Arrays.asList(createBackwardClassDefinitionExtension(),
createBackwardUsagesExtension(),
createBackwardHierarchyExtension(),
createBackwardSignatureExtension());
}
private static IndexExtension<LightRef, Integer, CompiledFileData> createBackwardUsagesExtension() {
@@ -62,13 +65,7 @@ public class CompilerIndices {
@NotNull
public DataIndexer<LightRef, Integer, CompiledFileData> getIndexer() {
return new DataIndexer<LightRef, Integer, CompiledFileData>() {
@NotNull
@Override
public Map<LightRef, Integer> map(@NotNull CompiledFileData inputData) {
return inputData.getReferences();
}
};
return CompiledFileData::getReferences;
}
@NotNull
@@ -113,13 +110,7 @@ public class CompilerIndices {
@NotNull
public DataIndexer<LightRef, Collection<LightRef>, CompiledFileData> getIndexer() {
return new DataIndexer<LightRef, Collection<LightRef>, CompiledFileData>() {
@NotNull
@Override
public Map<LightRef, Collection<LightRef>> map(@NotNull CompiledFileData inputData) {
return inputData.getBackwardHierarchy();
}
};
return CompiledFileData::getBackwardHierarchy;
}
@NotNull
@@ -129,27 +120,7 @@ public class CompilerIndices {
@NotNull
public DataExternalizer<Collection<LightRef>> getValueExternalizer() {
return new DataExternalizer<Collection<LightRef>>() {
@Override
public void save(@NotNull final DataOutput out, Collection<LightRef> value) throws IOException {
DataInputOutputUtil.writeSeq(out, value, new ThrowableConsumer<LightRef, IOException>() {
@Override
public void consume(LightRef lightRef) throws IOException {
LightRefDescriptor.INSTANCE.save(out, lightRef);
}
});
}
@Override
public Collection<LightRef> read(@NotNull final DataInput in) throws IOException {
return DataInputOutputUtil.readSeq(in, new ThrowableComputable<LightRef, IOException>() {
@Override
public LightRef compute() throws IOException {
return LightRefDescriptor.INSTANCE.read(in);
}
});
}
};
return createLightRefSeqExternalizer();
}
};
}
@@ -168,13 +139,7 @@ public class CompilerIndices {
@NotNull
public DataIndexer<LightRef, Void, CompiledFileData> getIndexer() {
return new DataIndexer<LightRef, Void, CompiledFileData>() {
@NotNull
@Override
public Map<LightRef, Void> map(@NotNull CompiledFileData inputData) {
return inputData.getDefinitions();
}
};
return CompiledFileData::getDefinitions;
}
@NotNull
@@ -189,4 +154,76 @@ public class CompilerIndices {
};
}
private static IndexExtension<SignatureData, Collection<LightRef>, CompiledFileData> createBackwardSignatureExtension() {
return new IndexExtension<SignatureData, Collection<LightRef>, CompiledFileData>() {
@NotNull
@Override
public ID<SignatureData, Collection<LightRef>> getName() {
return BACK_MEMBER_SIGN;
}
@NotNull
@Override
public DataIndexer<SignatureData, Collection<LightRef>, CompiledFileData> getIndexer() {
return CompiledFileData::getSignatureData;
}
@NotNull
@Override
public KeyDescriptor<SignatureData> getKeyDescriptor() {
return createSignatureDataDescriptor();
}
@NotNull
@Override
public DataExternalizer<Collection<LightRef>> getValueExternalizer() {
return createLightRefSeqExternalizer();
}
@Override
public int getVersion() {
return VERSION;
}
};
}
@NotNull
private static DataExternalizer<Collection<LightRef>> createLightRefSeqExternalizer() {
return new DataExternalizer<Collection<LightRef>>() {
@Override
public void save(@NotNull final DataOutput out, Collection<LightRef> value) throws IOException {
DataInputOutputUtilRt.writeSeq(out, value, lightRef -> LightRefDescriptor.INSTANCE.save(out, lightRef));
}
@Override
public Collection<LightRef> read(@NotNull final DataInput in) throws IOException {
return DataInputOutputUtilRt.readSeq(in, () -> LightRefDescriptor.INSTANCE.read(in));
}
};
}
private static KeyDescriptor<SignatureData> createSignatureDataDescriptor() {
return new KeyDescriptor<SignatureData>() {
@Override
public int getHashCode(SignatureData value) {
return value.hashCode();
}
@Override
public boolean isEqual(SignatureData val1, SignatureData val2) {
return val1.equals(val2);
}
@Override
public void save(@NotNull DataOutput out, SignatureData value) throws IOException {
DataInputOutputUtil.writeINT(out, value.getRawReturnType());
out.writeBoolean(value.isStatic());
}
@Override
public SignatureData read(@NotNull DataInput in) throws IOException {
return new SignatureData(DataInputOutputUtil.readINT(in), in.readBoolean());
}
};
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/AsmUtil.java
-57
View File
@@ -1,57 +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.jetbrains.jps.classFilesIndex;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.org.objectweb.asm.Type;
import java.util.Set;
/**
* @author Dmitry Batkovich
*/
public class AsmUtil {
private AsmUtil() {}
public static String getQualifiedClassName(final String name) {
return StringUtil.replaceChar(Type.getObjectType(name).getClassName(), '$', '.');
}
//char
//double
//float
//int
//long
//short
//boolean
//byte
//void
//Object
//String
//Class
private static final Set<String> ASM_PRIMITIVE_TYPES = ContainerUtil
.newHashSet("C", "D", "F", "I", "J", "S", "Z", "B", "V", "Ljava/lang/Object;", "Ljava/lang/String;", "Ljava/lang/Class;");
public static boolean isPrimitiveOrArrayOfPrimitives(final String asmType) {
for (int i = 0; i < asmType.length(); i++) {
if (asmType.charAt(i) != '[') {
return ASM_PRIMITIVE_TYPES.contains(asmType.substring(i));
}
}
throw new AssertionError("Illegal string: " + asmType);
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/TObjectIntHashMapExternalizer.java
-81
View File
@@ -1,81 +0,0 @@
/*
* Copyright 2000-2014 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.jps.classFilesIndex;
import com.intellij.util.io.DataExternalizer;
import gnu.trove.TObjectIntHashMap;
import gnu.trove.TObjectIntProcedure;
import org.jetbrains.annotations.NotNull;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* @author Dmitry Batkovich
*/
public class TObjectIntHashMapExternalizer<K> implements DataExternalizer<TObjectIntHashMap<K>> {
private final DataExternalizer<K> myKeyDataExternalizer;
public TObjectIntHashMapExternalizer(final DataExternalizer<K> keyDataExternalizer) {
myKeyDataExternalizer = keyDataExternalizer;
}
@Override
public void save(@NotNull final DataOutput out, final TObjectIntHashMap<K> map) throws IOException {
out.writeInt(map.size());
try {
map.forEachEntry(new TObjectIntProcedure<K>() {
@Override
public boolean execute(final K key, final int value) {
try {
myKeyDataExternalizer.save(out, key);
out.writeInt(value);
}
catch (final IOException e) {
throw new IoExceptionRuntimeWrapperException(e);
}
return true;
}
});
}
catch (final IoExceptionRuntimeWrapperException e) {
throw e.getIoException();
}
}
@Override
public TObjectIntHashMap<K> read(@NotNull final DataInput in) throws IOException {
final int size = in.readInt();
final TObjectIntHashMap<K> map = new TObjectIntHashMap<>(size);
for (int i = 0; i < size; i++) {
map.put(myKeyDataExternalizer.read(in), in.readInt());
}
return map;
}
private static class IoExceptionRuntimeWrapperException extends RuntimeException {
private final IOException myIoException;
private IoExceptionRuntimeWrapperException(final IOException ioException) {
myIoException = ioException;
}
public IOException getIoException() {
return myIoException;
}
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexer.java
-46
View File
@@ -1,46 +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.jetbrains.jps.classFilesIndex.indexer.api;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.KeyDescriptor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import org.jetbrains.org.objectweb.asm.ClassReader;
import java.util.Map;
/**
* @author Dmitry Batkovich
*/
public abstract class ClassFileIndexer<K, V> {
private final String myIndexCanonicalName;
public ClassFileIndexer(final String indexCanonicalName) {
myIndexCanonicalName = indexCanonicalName;
}
@NotNull
public abstract Map<K, V> map(ClassReader inputData, Mappings mappings);
public abstract KeyDescriptor<K> getKeyDescriptor();
public abstract DataExternalizer<V> getDataExternalizer();
public String getIndexCanonicalName() {
return myIndexCanonicalName;
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFileIndexerFactory.java
-25
View File
@@ -1,25 +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.jetbrains.jps.classFilesIndex.indexer.api;
/**
* @author Dmitry Batkovich
*/
public interface ClassFileIndexerFactory<K, V> {
ClassFileIndexer<K, V> create();
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndexWriter.java
-106
View File
@@ -1,106 +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.jetbrains.jps.classFilesIndex.indexer.api;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.io.PersistentHashMap;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageBase;
import org.jetbrains.jps.classFilesIndex.indexer.api.storage.ClassFilesIndexStorageWriter;
import org.jetbrains.jps.incremental.CompileContext;
import org.jetbrains.org.objectweb.asm.ClassReader;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexWriter<K, V> {
private static final Logger LOG = Logger.getInstance(ClassFilesIndexWriter.class);
private final ClassFileIndexer<K, V> myIndexer;
private final boolean myEmpty;
private final Mappings myMappings;
private final ClassFilesIndexStorageWriter<K, V> myIndex;
protected ClassFilesIndexWriter(final ClassFileIndexer<K, V> indexer, final CompileContext compileContext) {
myIndexer = indexer;
final File storageDir = getIndexRoot(compileContext);
final Set<String> containingFileNames = listFiles(storageDir);
if (!containingFileNames.contains("version") || !containingFileNames.contains(IndexState.STATE_FILE_NAME)) {
throw new IllegalStateException("version or state file for index " + indexer.getIndexCanonicalName() + " not found in " + storageDir.getAbsolutePath());
}
ClassFilesIndexStorageWriter<K, V> index = null;
IOException exception = null;
LOG.debug("start open... " + indexer.getIndexCanonicalName());
myMappings = compileContext.getProjectDescriptor().dataManager.getMappings();
for (int attempt = 0; attempt < 2; attempt++) {
try {
index = new ClassFilesIndexStorageWriter<>(storageDir,
myIndexer.getKeyDescriptor(),
myIndexer.getDataExternalizer(),
myMappings);
break;
}
catch (final IOException e) {
exception = e;
PersistentHashMap.deleteFilesStartingWith(ClassFilesIndexStorageBase.getIndexFile(storageDir));
}
}
LOG.debug("opened " + indexer.getIndexCanonicalName());
if (index == null) {
throw new RuntimeException(exception);
}
myIndex = index;
myEmpty = IndexState.EXIST != IndexState.load(storageDir) || exception != null;
IndexState.CORRUPTED.save(storageDir);
}
private static Set<String> listFiles(final File dir) {
final String[] containingFileNames = dir.list();
return containingFileNames == null ? Collections.<String>emptySet() : ContainerUtil.newHashSet(containingFileNames);
}
private File getIndexRoot(final CompileContext compileContext) {
final File rootFile = compileContext.getProjectDescriptor().dataManager.getDataPaths().getDataStorageRoot();
return ClassFilesIndexStorageBase.getIndexDir(myIndexer.getIndexCanonicalName(), rootFile);
}
public final boolean isEmpty() {
return myEmpty;
}
public final void close(final CompileContext compileContext) {
try {
myIndex.close();
IndexState.EXIST.save(getIndexRoot(compileContext));
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
public final void update(final String id, final ClassReader inputData) {
for (final Map.Entry<K, V> e : myIndexer.map(inputData, myMappings).entrySet()) {
myIndex.putData(e.getKey(), e.getValue(), id);
}
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/ClassFilesIndicesBuilder.java
-141
View File
@@ -1,141 +0,0 @@
/*
* Copyright 2000-2016 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.jps.classFilesIndex.indexer.api;
import com.intellij.compiler.instrumentation.InstrumentationClassFinder;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.ModuleChunk;
import org.jetbrains.jps.builders.java.JavaBuilderUtil;
import org.jetbrains.jps.incremental.BinaryContent;
import org.jetbrains.jps.incremental.CompileContext;
import org.jetbrains.jps.incremental.CompiledClass;
import org.jetbrains.jps.incremental.instrumentation.BaseInstrumentingBuilder;
import org.jetbrains.jps.service.JpsServiceManager;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.ClassWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndicesBuilder extends BaseInstrumentingBuilder {
public static final Logger LOG = Logger.getInstance(ClassFilesIndicesBuilder.class);
private static final String PRESENTABLE_NAME = "Class-files indexer";
private static final String PROGRESS_MESSAGE = "Indexing class-files...";
public static final String PROPERTY_NAME = "intellij.compiler.output.index";
private final Collection<ClassFilesIndexWriter> myIndexWriters = new ArrayList<>();
@Override
@SuppressWarnings("unchecked")
public void buildStarted(final CompileContext context) {
super.buildStarted(context);
final boolean isEnabled = isEnabled();
LOG.info("class files data index " + (isEnabled ? "enabled" : "disabled"));
if (!isEnabled) {
return;
}
final Set<String> enabledIndicesBuilders = ContainerUtil.newHashSet(System.getProperty(PROPERTY_NAME).split(";"));
final boolean forcedRecompilation = JavaBuilderUtil.isForcedRecompilationAllJavaModules(context);
final Iterable<ClassFileIndexerFactory> extensions = JpsServiceManager.getInstance().getExtensions(ClassFileIndexerFactory.class);
int newIndicesCount = 0;
for (final ClassFileIndexerFactory builder : extensions) {
if (enabledIndicesBuilders.contains(builder.getClass().getName())) {
final ClassFilesIndexWriter indexWriter = new ClassFilesIndexWriter(builder.create(), context);
if (!indexWriter.isEmpty()) {
myIndexWriters.add(indexWriter);
}
else if (forcedRecompilation) {
newIndicesCount++;
myIndexWriters.add(indexWriter);
}
else {
indexWriter.close(context);
}
}
}
if (forcedRecompilation) {
LOG.info(String.format("class files indexing: %d indices, %d new", myIndexWriters.size(), newIndicesCount));
}
else {
LOG.info(String.format("class files indexing: %d indices", myIndexWriters.size()));
}
}
@Override
public void buildFinished(final CompileContext context) {
super.buildFinished(context);
if (!isEnabled()) {
return;
}
for (final ClassFilesIndexWriter index : myIndexWriters) {
index.close(context);
}
myIndexWriters.clear();
}
@Nullable
@Override
protected BinaryContent instrument(final CompileContext context,
final CompiledClass compiled,
final ClassReader reader,
final ClassWriter writer,
final InstrumentationClassFinder finder) {
String className = compiled.getClassName();
if (className == null) {
LOG.debug("class name is empty for " + compiled.getOutputFile().getAbsolutePath());
}
else {
className = className.replace('.', '/');
for (final ClassFilesIndexWriter index : myIndexWriters) {
index.update(className, reader);
}
}
return null;
}
@Override
protected boolean canInstrument(final CompiledClass compiledClass, final int classFileVersion) {
return !"module-info".equals(compiledClass.getClassName());
}
@Override
protected boolean isEnabled(final CompileContext context, final ModuleChunk chunk) {
return isEnabled();
}
private static boolean isEnabled() {
return System.getProperty(PROPERTY_NAME) != null;
}
@Override
protected String getProgressMessage() {
return PROGRESS_MESSAGE;
}
@NotNull
@Override
public String getPresentableName() {
return PRESENTABLE_NAME;
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/IndexState.java
-55
View File
@@ -1,55 +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.jetbrains.jps.classFilesIndex.indexer.api;
import com.intellij.openapi.util.io.FileUtil;
import java.io.File;
import java.io.IOException;
/**
* @author Dmitry Batkovich
*/
public enum IndexState {
CORRUPTED,
NOT_EXIST,
EXIST;
public static final String STATE_FILE_NAME = "state";
public void save(final File indexDir) {
try {
FileUtil.writeToFile(new File(indexDir, STATE_FILE_NAME), name());
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
public static IndexState load(final File indexDir) {
try {
final File indexStateFile = new File(indexDir, STATE_FILE_NAME);
if (!indexStateFile.exists()) {
NOT_EXIST.save(indexDir);
return NOT_EXIST;
}
return Enum.valueOf(IndexState.class, FileUtil.loadFile(indexStateFile));
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/storage/ClassFilesIndexStorageBase.java
-200
View File
@@ -1,200 +0,0 @@
/*
* Copyright 2000-2014 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.jps.classFilesIndex.indexer.api.storage;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.SLRUCache;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorIntegerDescriptor;
import com.intellij.util.io.KeyDescriptor;
import com.intellij.util.io.PersistentHashMap;
import gnu.trove.TIntObjectHashMap;
import gnu.trove.TIntObjectProcedure;
import org.jetbrains.annotations.NotNull;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexStorageBase<K, V> {
private static final String INDEX_FILE_NAME = "index";
private static final int INITIAL_INDEX_SIZE = 16 * 1024;
private static final int CACHE_QUEUES_SIZE = 16 * 1024;
private final File myIndexFile;
private final KeyDescriptor<K> myKeyDescriptor;
private final DataExternalizer<V> myValueExternalizer;
private PersistentHashMap<K, CompiledDataValueContainer<V>> myMap;
protected final Lock myWriteLock = new ReentrantLock();
protected SLRUCache<K, CompiledDataValueContainer<V>> myCache;
public ClassFilesIndexStorageBase(final File indexDir, final KeyDescriptor<K> keyDescriptor, final DataExternalizer<V> valueExternalizer)
throws IOException {
myIndexFile = getIndexFile(indexDir);
myKeyDescriptor = keyDescriptor;
myValueExternalizer = valueExternalizer;
initialize();
}
private void initialize() throws IOException {
myMap = new PersistentHashMap<>(myIndexFile, myKeyDescriptor,
createValueContainerExternalizer(myValueExternalizer),
INITIAL_INDEX_SIZE);
myCache = new SLRUCache<K, CompiledDataValueContainer<V>>(CACHE_QUEUES_SIZE, CACHE_QUEUES_SIZE) {
@NotNull
@Override
public CompiledDataValueContainer<V> createValue(final K key) {
try {
final CompiledDataValueContainer<V> valueContainer = myMap.get(key);
if (valueContainer != null) {
return valueContainer;
}
}
catch (final IOException e) {
throw new RuntimeException(e);
}
return new CompiledDataValueContainer<>();
}
@Override
protected void onDropFromCache(final K key, final CompiledDataValueContainer<V> value) {
try {
myMap.put(key, value);
}
catch (final IOException e) {
throw new RuntimeException(e);
}
}
};
}
public void delete() throws IOException {
try {
myWriteLock.lock();
doDelete();
}
finally {
myWriteLock.unlock();
}
}
private void doDelete() throws IOException {
close();
PersistentHashMap.deleteFilesStartingWith(myIndexFile);
}
public void clear() throws IOException {
try {
myWriteLock.lock();
doDelete();
initialize();
}
finally {
myWriteLock.unlock();
}
}
public void flush() {
try {
myWriteLock.lock();
myCache.clear();
}
finally {
myWriteLock.unlock();
}
myMap.force();
}
public void close() throws IOException {
flush();
myMap.close();
}
public static class CompiledDataValueContainer<V> {
private final TIntObjectHashMap<V> myUnderlying;
private CompiledDataValueContainer(final TIntObjectHashMap<V> map) {
myUnderlying = map;
}
private CompiledDataValueContainer() {
this(new TIntObjectHashMap<>());
}
public void putValue(final Integer inputId, final V value) {
myUnderlying.put(inputId, value);
}
public Collection<V> getValues() {
return ContainerUtil.list((V[])myUnderlying.getValues());
}
}
public static File getIndexFile(final File indexDir) {
return new File(indexDir, INDEX_FILE_NAME);
}
public static File getIndexDir(final String indexName, final File projectSystemBuildDirectory) {
return new File(projectSystemBuildDirectory, "compiler.output.data.indices/" + indexName);
}
private static <V> DataExternalizer<CompiledDataValueContainer<V>> createValueContainerExternalizer(final DataExternalizer<V> valueExternalizer) {
return new DataExternalizer<CompiledDataValueContainer<V>>() {
@Override
public void save(@NotNull final DataOutput out, final CompiledDataValueContainer<V> value) throws IOException {
final TIntObjectHashMap<V> underlying = value.myUnderlying;
out.writeInt(underlying.size());
final IOException[] ioException = {null};
underlying.forEachEntry(new TIntObjectProcedure<V>() {
@Override
public boolean execute(final int k, final V v) {
try {
EnumeratorIntegerDescriptor.INSTANCE.save(out, k);
valueExternalizer.save(out, v);
return true;
}
catch (final IOException e) {
ioException[0] = e;
return false;
}
}
});
if (ioException[0] != null) {
throw ioException[0];
}
}
@Override
public CompiledDataValueContainer<V> read(@NotNull final DataInput in) throws IOException {
final TIntObjectHashMap<V> map = new TIntObjectHashMap<>();
final int size = in.readInt();
for (int i = 0; i < size; i++) {
map.put(EnumeratorIntegerDescriptor.INSTANCE.read(in), valueExternalizer.read(in));
}
return new CompiledDataValueContainer<>(map);
}
};
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/api/storage/ClassFilesIndexStorageWriter.java
-50
View File
@@ -1,50 +0,0 @@
/*
* Copyright 2000-2014 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.jps.classFilesIndex.indexer.api.storage;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.KeyDescriptor;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import java.io.File;
import java.io.IOException;
/**
* @author Dmitry Batkovich
*/
public class ClassFilesIndexStorageWriter<K, V> extends ClassFilesIndexStorageBase<K, V> {
private final Mappings myMappings;
public ClassFilesIndexStorageWriter(final File indexDir,
final KeyDescriptor<K> keyDescriptor,
final DataExternalizer<V> valueExternalizer,
final Mappings mappings) throws IOException {
super(indexDir, keyDescriptor, valueExternalizer);
myMappings = mappings;
}
public void putData(final K key, final V value, final String containingClass) {
final int id = myMappings.getName(containingClass);
try {
myWriteLock.lock();
final CompiledDataValueContainer<V> container = myCache.get(key);
container.putValue(id, value);
}
finally {
myWriteLock.unlock();
}
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/EnumeratedMethodIncompleteSignature.java
-92
View File
@@ -1,92 +0,0 @@
/*
* Copyright 2000-2014 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.jps.classFilesIndex.indexer.impl;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorStringDescriptor;
import org.jetbrains.annotations.NotNull;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* @author Dmitry Batkovich
*/
public class EnumeratedMethodIncompleteSignature {
private final int myOwner;
private final int myName;
private final boolean myStatic;
public EnumeratedMethodIncompleteSignature(final int owner, final int name, final boolean aStatic) {
myOwner = owner;
myName = name;
myStatic = aStatic;
}
public int getOwner() {
return myOwner;
}
public int getName() {
return myName;
}
public boolean isStatic() {
return myStatic;
}
public static DataExternalizer<EnumeratedMethodIncompleteSignature> createDataExternalizer() {
return new DataExternalizer<EnumeratedMethodIncompleteSignature>() {
@Override
public void save(@NotNull final DataOutput out, final EnumeratedMethodIncompleteSignature value) throws IOException {
out.writeInt(value.getOwner());
out.writeInt(value.getName());
out.writeBoolean(value.isStatic());
}
@Override
public EnumeratedMethodIncompleteSignature read(@NotNull final DataInput in) throws IOException {
return new EnumeratedMethodIncompleteSignature(in.readInt(),
in.readInt(),
in.readBoolean());
}
};
}
@Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final EnumeratedMethodIncompleteSignature that = (EnumeratedMethodIncompleteSignature)o;
if (myName != that.myName) return false;
if (myOwner != that.myOwner) return false;
if (myStatic != that.myStatic) return false;
return true;
}
@Override
public int hashCode() {
int result = myOwner;
result = 31 * result + myName;
result = 31 * result + (myStatic ? 1 : 0);
return result;
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexer.java
-93
View File
@@ -1,93 +0,0 @@
/*
* Copyright 2000-2016 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.jps.classFilesIndex.indexer.impl;
import com.intellij.util.io.DataExternalizer;
import com.intellij.util.io.EnumeratorIntegerDescriptor;
import com.intellij.util.io.KeyDescriptor;
import gnu.trove.TObjectIntHashMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.builders.java.dependencyView.Mappings;
import org.jetbrains.jps.classFilesIndex.AsmUtil;
import org.jetbrains.jps.classFilesIndex.TObjectIntHashMapExternalizer;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexer;
import org.jetbrains.org.objectweb.asm.*;
import java.util.HashMap;
import java.util.Map;
/**
* @author Dmitry Batkovich
*/
public class MethodsUsageIndexer extends ClassFileIndexer<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> {
public static final String METHODS_USAGE_INDEX_CANONICAL_NAME = "MethodsUsageIndex";
public MethodsUsageIndexer() {
super(METHODS_USAGE_INDEX_CANONICAL_NAME);
}
@NotNull
@Override
public Map<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> map(final ClassReader inputData, final Mappings mappings) {
final Map<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> map =
new HashMap<>();
final MethodVisitor methodVisitor = new MethodVisitor(Opcodes.API_VERSION) {
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
final Type returnType = Type.getReturnType(desc);
if (AsmUtil.isPrimitiveOrArrayOfPrimitives(returnType.getDescriptor()) || "<init>".equals(name)) {
return;
}
final boolean isStatic = opcode == Opcodes.INVOKESTATIC;
final String returnClassName = returnType.getInternalName();
if (!owner.equals(returnClassName) || isStatic) {
final EnumeratedMethodIncompleteSignature mi =
new EnumeratedMethodIncompleteSignature(mappings.getName(owner), mappings.getName(name), isStatic);
final int enumeratedClassName = mappings.getName(returnClassName);
TObjectIntHashMap<EnumeratedMethodIncompleteSignature> occurrences = map.get(enumeratedClassName);
if (occurrences == null) {
occurrences = new TObjectIntHashMap<>();
map.put(enumeratedClassName, occurrences);
}
if (!occurrences.increment(mi)) {
occurrences.put(mi, 1);
}
}
}
};
inputData.accept(new ClassVisitor(Opcodes.API_VERSION) {
@Override
public MethodVisitor visitMethod(final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions) {
return methodVisitor;
}
}, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
return map;
}
@Override
public KeyDescriptor<Integer> getKeyDescriptor() {
return EnumeratorIntegerDescriptor.INSTANCE;
}
@Override
public DataExternalizer<TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> getDataExternalizer() {
return new TObjectIntHashMapExternalizer<>(EnumeratedMethodIncompleteSignature.createDataExternalizer());
}
}
jps/jps-builders/src/org/jetbrains/jps/classFilesIndex/indexer/impl/MethodsUsageIndexerFactory.java
-30
View File
@@ -1,30 +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.jetbrains.jps.classFilesIndex.indexer.impl;
import gnu.trove.TObjectIntHashMap;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexer;
import org.jetbrains.jps.classFilesIndex.indexer.api.ClassFileIndexerFactory;
/**
* @author Dmitry Batkovich
*/
public class MethodsUsageIndexerFactory implements ClassFileIndexerFactory<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> {
@Override
public ClassFileIndexer<Integer, TObjectIntHashMap<EnumeratedMethodIncompleteSignature>> create() {
return new MethodsUsageIndexer();
}
}
jps/jps-builders/src/org/jetbrains/jps/incremental/JavaBuilderService.java
-2
View File
@@ -19,7 +19,6 @@ import org.jetbrains.annotations.NotNull;
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.instrumentation.NotNullInstrumentingBuilder;
import org.jetbrains.jps.incremental.instrumentation.RmiStubsGenerator;
@@ -50,7 +49,6 @@ public class JavaBuilderService extends BuilderService {
return Arrays.asList(new JavaBuilder(SharedThreadPool.getInstance()),
new NotNullInstrumentingBuilder(),
new RmiStubsGenerator(),
new ClassFilesIndicesBuilder(),
new BackwardReferenceIndexBuilder());
}
platform/util/resources/misc/registry.properties
-1
View File
@@ -556,7 +556,6 @@ svn.use.svnkit.for.https.server.certificate.check.description=Use SVNKit to perf
svn.use.sqlite.jdbc=true
svn.use.sqlite.jdbc.description=Use SQLite JDBC driver (instead of SQLJet) to access svn working copy database
completion.enable.relevant.method.chain.suggestions=false
ide.mac.message.sheets.java.emulation=false
ide.mac.message.sheets.java.emulation.description=Use Java message sheets instead of native ones
ide.mac.message.sheets.java.emulation.dialogs=true
resources/src/META-INF/IdeaPlugin.xml
-4
View File
@@ -55,10 +55,6 @@
</application-components>
<project-components>
<component>
<implementation-class>com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexFeaturesHolder</implementation-class>
</component>
<component>
<interface-class>com.intellij.psi.RefResolveService</interface-class>
<implementation-class>com.intellij.psi.refResolve.RefResolveServiceImpl</implementation-class>
resources/src/idea/RichPlatformPlugin.xml
-1
View File
@@ -370,7 +370,6 @@
<projectStructure.sourceRootEditHandler implementation="com.intellij.openapi.roots.ui.configuration.JavaResourceRootEditHandler"/>
<projectStructure.sourceRootEditHandler implementation="com.intellij.openapi.roots.ui.configuration.JavaTestResourceRootEditHandler"/>
<buildProcess.parametersProvider implementation="com.intellij.compiler.classFilesIndex.api.index.ClassFilesIndexerBuilderParametersProvider"/>
<buildProcess.parametersProvider implementation="com.intellij.compiler.CompilerReferenceIndexBuildParametersProvider"/>
</extensions>
<extensions defaultExtensionNs="org.jetbrains">