From c08f73e288fc55924e3d8e3f4571a6d0e711fc19 Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Fri, 16 Dec 2016 19:07:27 +0300 Subject: [PATCH] javac ast indices: get rid of Name#toUtf() usages --- .../CompilerHierarchySearchType.java | 10 +- .../backwardRefs/CompilerReferenceReader.java | 4 +- .../backwardRefs/JavaLightUsageAdapter.java | 19 ++- .../backwardRefs/LanguageLightRefAdapter.java | 6 +- .../compiler/server/BuildManager.java | 5 - .../BackwardReferenceIndexWriter.java | 18 +-- .../jps/backwardRefs/ByteArrayEnumerator.java | 108 ------------------ .../CompilerBackwardReferenceIndex.java | 6 +- .../jps/backwardRefs/NameEnumerator.java | 51 +++++++++ .../backwardRefs/index/CompilerIndices.java | 2 +- .../ast/JavacReferenceCollectorListener.java | 9 +- .../jps/javac/ast/api/JavacFileData.java | 24 +--- .../jetbrains/jps/javac/ast/api/JavacRef.java | 68 ++++++----- .../jps/javac/ast/api/NameTableCache.java | 43 +++++++ .../references/ReferenceIndexTestBase.kt | 13 +-- 15 files changed, 175 insertions(+), 211 deletions(-) delete mode 100644 jps/jps-builders/src/org/jetbrains/jps/backwardRefs/ByteArrayEnumerator.java create mode 100644 jps/jps-builders/src/org/jetbrains/jps/backwardRefs/NameEnumerator.java create mode 100644 jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/NameTableCache.java diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java index 775757bff5ed..cc74b983c227 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java @@ -18,7 +18,7 @@ package com.intellij.compiler.backwardRefs; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiNamedElement; import com.intellij.psi.impl.source.PsiFileWithStubSupport; -import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; +import org.jetbrains.jps.backwardRefs.NameEnumerator; import org.jetbrains.jps.backwardRefs.LightRef; import java.util.Collection; @@ -39,8 +39,8 @@ enum CompilerHierarchySearchType { } @Override - Object[] convertToIds(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator) { - return lightRef.stream().map(r -> byteArrayEnumerator.getName(((LightRef.LightClassHierarchyElementDef)r).getName())).toArray(String[]::new); + Object[] convertToIds(Collection lightRef, NameEnumerator nameEnumerator) { + return lightRef.stream().map(r -> nameEnumerator.getName(((LightRef.LightClassHierarchyElementDef)r).getName())).toArray(String[]::new); } }, FUNCTIONAL_EXPRESSION { @@ -58,7 +58,7 @@ enum CompilerHierarchySearchType { } @Override - Object[] convertToIds(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator) { + Object[] convertToIds(Collection lightRef, NameEnumerator nameEnumerator) { return lightRef.stream().map(r -> ((LightRef.LightFunExprDef) r).getId()).toArray(Integer[]::new); } }; @@ -70,5 +70,5 @@ enum CompilerHierarchySearchType { abstract Class getRequiredClass(LanguageLightRefAdapter adapter); - abstract Object[] convertToIds(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator); + abstract Object[] convertToIds(Collection lightRef, NameEnumerator nameEnumerator); } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java index 523d1d2fda67..567afec8a78a 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java @@ -30,7 +30,7 @@ import gnu.trove.THashSet; import gnu.trove.TIntHashSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; +import org.jetbrains.jps.backwardRefs.NameEnumerator; import org.jetbrains.jps.backwardRefs.CompilerBackwardReferenceIndex; import org.jetbrains.jps.backwardRefs.LightRef; import org.jetbrains.jps.backwardRefs.index.CompilerIndices; @@ -96,7 +96,7 @@ class CompilerReferenceReader { } @NotNull - ByteArrayEnumerator getNameEnumerator() { + NameEnumerator getNameEnumerator() { return myIndex.getByteSeqEum(); } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java index cbb4031165d7..b8a0a45e5a9f 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java @@ -28,10 +28,9 @@ import com.intellij.psi.util.ClassUtil; import com.intellij.util.ObjectUtils; import com.intellij.util.Processor; import com.intellij.util.containers.ContainerUtil; -import com.sun.tools.javac.util.Convert; import gnu.trove.TIntHashSet; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; +import org.jetbrains.jps.backwardRefs.NameEnumerator; import org.jetbrains.jps.backwardRefs.LightRef; import java.util.ArrayList; @@ -46,7 +45,7 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { } @Override - public LightRef asLightUsage(@NotNull PsiElement element, @NotNull ByteArrayEnumerator names) { + public LightRef asLightUsage(@NotNull PsiElement element, @NotNull NameEnumerator names) { if (mayBeVisibleOutsideOwnerFile(element)) { if (element instanceof PsiField) { final PsiField field = (PsiField)element; @@ -55,7 +54,7 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { final String jvmOwnerName = ClassUtil.getJVMClassName(aClass); final String name = field.getName(); if (name == null || jvmOwnerName == null) return null; - return new LightRef.JavaLightFieldRef(id(jvmOwnerName, names), id(name, names)); + return new LightRef.JavaLightFieldRef(names.enumerate(jvmOwnerName), names.enumerate(name)); } else if (element instanceof PsiMethod) { final PsiClass aClass = ((PsiMethod)element).getContainingClass(); @@ -65,12 +64,12 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { final PsiMethod method = (PsiMethod)element; final String name = method.isConstructor() ? "" : method.getName(); final int parametersCount = method.getParameterList().getParametersCount(); - return new LightRef.JavaLightMethodRef(id(jvmOwnerName, names), id(name, names), parametersCount); + return new LightRef.JavaLightMethodRef(names.enumerate(jvmOwnerName), names.enumerate(name), parametersCount); } else if (element instanceof PsiClass) { final String jvmClassName = ClassUtil.getJVMClassName((PsiClass)element); if (jvmClassName != null) { - return new LightRef.JavaLightClassRef(id(jvmClassName, names)); + return new LightRef.JavaLightClassRef(names.enumerate(jvmClassName)); } } } @@ -81,7 +80,7 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { @Override public List getHierarchyRestrictedToLibraryScope(@NotNull LightRef baseRef, @NotNull PsiElement basePsi, - @NotNull ByteArrayEnumerator names, @NotNull GlobalSearchScope libraryScope) { + @NotNull NameEnumerator names, @NotNull GlobalSearchScope libraryScope) { final PsiClass baseClass = ObjectUtils.notNull(basePsi instanceof PsiClass ? (PsiClass)basePsi : ReadAction.compute(() -> (PsiMember)basePsi).getContainingClass()); final List overridden = new ArrayList<>(); @@ -89,7 +88,7 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { if (c.hasModifierProperty(PsiModifier.PRIVATE)) return true; String qName = ReadAction.compute(() -> c.getQualifiedName()); if (qName == null) return true; - overridden.add(baseRef.override(id(qName, names))); + overridden.add(baseRef.override(names.enumerate(qName))); return true; }; @@ -139,8 +138,4 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { if (((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.PRIVATE)) return false; return true; } - - private static int id(String name, ByteArrayEnumerator names) { - return names.enumerate(Convert.string2utf(name)); - } } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java index fb4ff7f739f4..8fb3dbe46ecc 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java @@ -22,7 +22,7 @@ import com.intellij.psi.impl.source.PsiFileWithStubSupport; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; +import org.jetbrains.jps.backwardRefs.NameEnumerator; import org.jetbrains.jps.backwardRefs.LightRef; import java.util.List; @@ -43,7 +43,7 @@ public interface LanguageLightRefAdapter { * @return */ @Nullable - LightRef asLightUsage(@NotNull PsiElement element, @NotNull ByteArrayEnumerator names); + LightRef asLightUsage(@NotNull PsiElement element, @NotNull NameEnumerator names); /** * @return "hierarchy" of given element inside the libraries scope. @@ -51,7 +51,7 @@ public interface LanguageLightRefAdapter { @NotNull List getHierarchyRestrictedToLibraryScope(@NotNull LightRef baseRef, @NotNull PsiElement basePsi, - @NotNull ByteArrayEnumerator names, + @NotNull NameEnumerator names, @NotNull GlobalSearchScope libraryScope); /** diff --git a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java index 9c53b30da881..a5b5b7a9dc1e 100644 --- a/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java +++ b/java/compiler/impl/src/com/intellij/compiler/server/BuildManager.java @@ -1166,11 +1166,6 @@ public class BuildManager implements Disposable { cmdLine.addParameters(args); } - //TODO[Dmitry Batkovich] should be replaced with the proper solution - if (sdkVersion != null && sdkVersion.isAtLeast(JavaSdkVersion.JDK_1_9)) { - cmdLine.addParameters("--add-exports", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"); - } - @SuppressWarnings("UnnecessaryFullyQualifiedName") final Class launcherClass = org.jetbrains.jps.cmdline.Launcher.class; diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java index 1b0495bc9078..a175cb12fb16 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java +++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java @@ -125,23 +125,23 @@ public class BackwardReferenceIndexWriter { @Nullable LightRef enumerateNames(JavacRef ref) { - ByteArrayEnumerator byteArrayEnumerator = myIndex.getByteSeqEum(); + NameEnumerator nameEnumerator = myIndex.getByteSeqEum(); if (ref instanceof JavacRef.JavacClass) { if (!isPrivate(ref) && !((JavacRef.JavacClass)ref).isAnonymous()) { - return new LightRef.JavaLightClassRef(id(ref, byteArrayEnumerator)); + return new LightRef.JavaLightClassRef(id(ref, nameEnumerator)); } } else { - byte[] ownerName = ref.getOwnerName(); + String ownerName = ref.getOwnerName(); if (isPrivate(ref)) { return null; } if (ref instanceof JavacRef.JavacField) { - return new LightRef.JavaLightFieldRef(id(ownerName, byteArrayEnumerator), id(ref, byteArrayEnumerator)); + return new LightRef.JavaLightFieldRef(id(ownerName, nameEnumerator), id(ref, nameEnumerator)); } else if (ref instanceof JavacRef.JavacMethod) { int paramCount = ((JavacRef.JavacMethod) ref).getParamCount(); - return new LightRef.JavaLightMethodRef(id(ownerName, byteArrayEnumerator), id(ref, byteArrayEnumerator), paramCount); + return new LightRef.JavaLightMethodRef(id(ownerName, nameEnumerator), id(ref, nameEnumerator), paramCount); } else { throw new AssertionError("unexpected symbol: " + ref + " class: " + ref.getClass()); @@ -154,12 +154,12 @@ public class BackwardReferenceIndexWriter { return ref.getModifiers().contains(Modifier.PRIVATE); } - private static int id(JavacRef ref, ByteArrayEnumerator byteArrayEnumerator) { - return id(ref.getName(), byteArrayEnumerator); + private static int id(JavacRef ref, NameEnumerator nameEnumerator) { + return id(ref.getName(), nameEnumerator); } - private static int id(byte[] name, ByteArrayEnumerator byteArrayEnumerator) { - return byteArrayEnumerator.enumerate(name); + private static int id(String name, NameEnumerator nameEnumerator) { + return nameEnumerator.enumerate(name); } private static boolean areAllJavaModulesAffected(CompileContext context) { diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/ByteArrayEnumerator.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/ByteArrayEnumerator.java deleted file mode 100644 index 4854c3fcec41..000000000000 --- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/ByteArrayEnumerator.java +++ /dev/null @@ -1,108 +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.backwardRefs; - -import com.intellij.util.ObjectUtils; -import com.intellij.util.io.*; -import com.sun.tools.javac.util.Convert; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jps.builders.storage.BuildDataCorruptedException; - -import java.io.*; -import java.util.Arrays; - -public class ByteArrayEnumerator extends PersistentEnumeratorDelegate { - @NotNull - private final CachingEnumerator myCache; - - public ByteArrayEnumerator(@NotNull final File file) throws IOException { - super(file, ByteSequenceDataExternalizer.INSTANCE, 1024 * 4, null); - myCache = new CachingEnumerator(new DataEnumerator() { - @Override - public int enumerate(@Nullable byte[] value) throws IOException { - return ByteArrayEnumerator.super.enumerate(value); - } - - @Nullable - @Override - public byte[] valueOf(int idx) throws IOException { - return ByteArrayEnumerator.super.valueOf(idx); - } - }, ByteSequenceDataExternalizer.INSTANCE); - } - - @Override - public synchronized int enumerate(@Nullable byte[] value) { - try { - return myCache.enumerate(value); - } - catch (IOException e) { - throw new BuildDataCorruptedException(e); - } - } - - @Nullable - @Override - public synchronized byte[] valueOf(int idx) throws IOException { - return myCache.valueOf(idx); - } - - @Override - public synchronized void close() throws IOException { - super.close(); - myCache.close(); - } - - @NotNull - public String getName(int idx) { - try { - return Convert.utf2string(ObjectUtils.notNull(valueOf(idx))); - } - catch (IOException e) { - throw new RuntimeException(e); - } - } - - private static class ByteSequenceDataExternalizer implements KeyDescriptor, DifferentSerializableBytesImplyNonEqualityPolicy { - private static final ByteSequenceDataExternalizer INSTANCE = new ByteSequenceDataExternalizer(); - - @Override - public void save(@NotNull DataOutput out, byte[] value) throws IOException { - out.writeInt(value.length); - out.write(value); - } - - @Override - public byte[] read(@NotNull DataInput in) throws IOException { - final int len = in.readInt(); - final byte[] buf = new byte[len]; - in.readFully(buf); - return buf; - } - - @Override - public int getHashCode(byte[] value) { - return Arrays.hashCode(value); - } - - @Override - public boolean isEqual(byte[] val1, byte[] val2) { - return Arrays.equals(val1, val2); - } - } -} - diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java index 6625afccacc8..d9fe9f0d9b12 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java +++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/CompilerBackwardReferenceIndex.java @@ -45,7 +45,7 @@ public class CompilerBackwardReferenceIndex { private static final String VERSION_FILE = "version"; private final Map, InvertedIndex> myIndices; - private final ByteArrayEnumerator myNameEnumerator; + private final NameEnumerator myNameEnumerator; private final PersistentStringEnumerator myFilePathEnumerator; private final File myIndicesDir; private final LowMemoryWatcher myLowMemoryWatcher = LowMemoryWatcher.register(new Runnable() { @@ -87,7 +87,7 @@ public class CompilerBackwardReferenceIndex { myIndices.put(indexExtension.getName(), new CompilerMapReduceIndex(indexExtension, myIndicesDir)); } - myNameEnumerator = new ByteArrayEnumerator(new File(myIndicesDir, NAME_ENUM_TAB)); + myNameEnumerator = new NameEnumerator(new File(myIndicesDir, NAME_ENUM_TAB)); } catch (IOException e) { removeIndexFiles(myIndicesDir); @@ -105,7 +105,7 @@ public class CompilerBackwardReferenceIndex { } @NotNull - public ByteArrayEnumerator getByteSeqEum() { + public NameEnumerator getByteSeqEum() { return myNameEnumerator; } diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/NameEnumerator.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/NameEnumerator.java new file mode 100644 index 000000000000..8dae8ae53a23 --- /dev/null +++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/NameEnumerator.java @@ -0,0 +1,51 @@ +/* + * 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.backwardRefs; + +import com.intellij.util.ObjectUtils; +import com.intellij.util.io.PersistentStringEnumerator; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.builders.storage.BuildDataCorruptedException; + +import java.io.File; +import java.io.IOException; + +public class NameEnumerator extends PersistentStringEnumerator { + public NameEnumerator(@NotNull File file) throws IOException { + super(file); + } + + @Override + public int enumerate(String value) { + try { + return super.enumerate(value); + } + catch (IOException e) { + throw new BuildDataCorruptedException(e); + } + } + + @NotNull + public String getName(int idx) { + try { + return ObjectUtils.notNull(valueOf(idx)); + } + catch (IOException e) { + throw new RuntimeException(e); + } + } +} + diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerIndices.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerIndices.java index beaa94ca293f..3f4eeda44cfe 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerIndices.java +++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/index/CompilerIndices.java @@ -38,7 +38,7 @@ import java.util.Map; public class CompilerIndices { //TODO manage version separately - public final static int VERSION = 0; + public final static int VERSION = 1; public final static ID BACK_USAGES = ID.create("back.refs"); public final static ID> BACK_HIERARCHY = ID.create("back.hierarchy"); diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java index eae35d8fea7d..9d8fdacf7b14 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java @@ -28,6 +28,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.javac.ast.api.JavacDef; import org.jetbrains.jps.javac.ast.api.JavacFileData; import org.jetbrains.jps.javac.ast.api.JavacRef; +import org.jetbrains.jps.javac.ast.api.NameTableCache; import javax.lang.model.element.Element; import javax.lang.model.element.ElementKind; @@ -48,6 +49,7 @@ final class JavacReferenceCollectorListener implements TaskListener { private final Elements myElementUtility; private final Types myTypeUtility; private final Trees myTreeUtility; + private final NameTableCache myNameTableCache; private NotNullLazyValue myAsterisk = new NotNullLazyValue() { @NotNull @@ -96,6 +98,7 @@ final class JavacReferenceCollectorListener implements TaskListener { myTypeUtility = typeUtility; myTreeUtility = treeUtility; myAstScanner = JavacTreeRefScanner.createASTScanner(); + myNameTableCache = new NameTableCache(elementUtility); } @Override @@ -161,7 +164,7 @@ final class JavacReferenceCollectorListener implements TaskListener { @Override public JavacRef.JavacElementRefBase asJavacRef(Element element) { - return JavacRef.JavacElementRefBase.fromElement(element, myElementUtility); + return JavacRef.JavacElementRefBase.fromElement(element, myNameTableCache); } @Override @@ -211,7 +214,7 @@ final class JavacReferenceCollectorListener implements TaskListener { // member import for (Element memberElement : myElementUtility.getAllMembers((TypeElement)ownerElement)) { if (memberElement.getSimpleName() == name) { - elements.add(JavacRef.JavacElementRefBase.fromElement(memberElement, myElementUtility)); + elements.add(JavacRef.JavacElementRefBase.fromElement(memberElement, myNameTableCache)); } } } @@ -228,7 +231,7 @@ final class JavacReferenceCollectorListener implements TaskListener { for (Element element = baseImport; element != null && element.getKind() != ElementKind.PACKAGE; element = element.getEnclosingElement()) { - collector.add(JavacRef.JavacElementRefBase.fromElement(element, myElementUtility)); + collector.add(JavacRef.JavacElementRefBase.fromElement(element, myNameTableCache)); } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java index 6fb81e630d3a..4528e5c43c66 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java @@ -205,17 +205,17 @@ public class JavacFileData { } else if (ref instanceof JavacRef.JavacField) { out.writeByte(FIELD_MARKER); - writeBytes(out, ref.getOwnerName()); + IOUtil.writeUTF(out, ref.getOwnerName()); } else if (ref instanceof JavacRef.JavacMethod) { out.writeByte(METHOD_MARKER); - writeBytes(out, ref.getOwnerName()); + IOUtil.writeUTF(out, ref.getOwnerName()); out.write(((JavacRef.JavacMethod)ref).getParamCount()); } else { throw new IllegalStateException("unknown type: " + ref.getClass()); } writeModifiers(out, ref.getModifiers()); - writeBytes(out, ref.getName()); + IOUtil.writeUTF(out, ref.getName()); } @Override @@ -223,28 +223,16 @@ public class JavacFileData { final byte marker = in.readByte(); switch (marker) { case CLASS_MARKER: - return new JavacRef.JavacClassImpl(in.readBoolean(), readModifiers(in), readBytes(in)); + return new JavacRef.JavacClassImpl(in.readBoolean(), readModifiers(in), IOUtil.readUTF(in)); case METHOD_MARKER: - return new JavacRef.JavacMethodImpl(readBytes(in), in.readByte(), readModifiers(in), readBytes(in)); + return new JavacRef.JavacMethodImpl(IOUtil.readUTF(in), in.readByte(), readModifiers(in), IOUtil.readUTF(in)); case FIELD_MARKER: - return new JavacRef.JavacFieldImpl(readBytes(in), readModifiers(in), readBytes(in)); + return new JavacRef.JavacFieldImpl(IOUtil.readUTF(in), readModifiers(in), IOUtil.readUTF(in)); default: throw new IllegalStateException("unknown marker " + marker); } } - private void writeBytes(DataOutput out, byte[] bytes) throws IOException { - out.writeInt(bytes.length); - out.write(bytes); - } - - private byte[] readBytes(DataInput in) throws IOException { - final int len = in.readInt(); - final byte[] buf = new byte[len]; - in.readFully(buf); - return buf; - } - private void writeModifiers(final DataOutput output, Set modifiers) throws IOException { DataInputOutputUtil.writeSeq(output, modifiers, new ThrowableConsumer() { @Override diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java index cb1228c5105e..6458c8c2b1e9 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java @@ -15,23 +15,21 @@ */ package org.jetbrains.jps.javac.ast.api; -import com.sun.tools.javac.util.Name; import org.jetbrains.annotations.NotNull; import javax.lang.model.element.*; -import javax.lang.model.util.Elements; import java.util.Set; public interface JavacRef { JavacRef[] EMPTY_ARRAY = new JavacRef[0]; @NotNull - byte[] getName(); + String getName(); Set getModifiers(); @NotNull - byte[] getOwnerName(); + String getOwnerName(); interface JavacClass extends JavacRef { boolean isAnonymous(); @@ -45,17 +43,17 @@ public interface JavacRef { } abstract class JavacRefBase implements JavacRef { - private final byte[] myName; + private final String myName; private final Set myModifiers; - protected JavacRefBase(byte[] name, Set modifiers) { + protected JavacRefBase(String name, Set modifiers) { myName = name; myModifiers = modifiers; } @NotNull @Override - public final byte[] getName() { + public final String getName() { return myName; } @@ -68,14 +66,14 @@ public interface JavacRef { class JavacClassImpl extends JavacRefBase implements JavacClass { private boolean myAnonymous; - public JavacClassImpl(boolean anonymous, Set modifiers, byte[] name) { + public JavacClassImpl(boolean anonymous, Set modifiers, String name) { super(name, modifiers); myAnonymous = anonymous; } @NotNull @Override - public byte[] getOwnerName() { + public String getOwnerName() { throw new UnsupportedOperationException(); } @@ -85,10 +83,10 @@ public interface JavacRef { } class JavacMethodImpl extends JavacRefBase implements JavacMethod { - private final byte[] myOwnerName; + private final String myOwnerName; private final byte myParamCount; - public JavacMethodImpl(byte[] ownerName, byte paramCount, Set modifiers, byte[] name) { + public JavacMethodImpl(String ownerName, byte paramCount, Set modifiers, String name) { super(name, modifiers); myOwnerName = ownerName; myParamCount = paramCount; @@ -100,33 +98,33 @@ public interface JavacRef { @NotNull @Override - public byte[] getOwnerName() { + public String getOwnerName() { return myOwnerName; } } class JavacFieldImpl extends JavacRefBase implements JavacField { - private final byte[] myOwnerName; + private final String myOwnerName; - public JavacFieldImpl(byte[] ownerName, Set modifiers, byte[] name) { + public JavacFieldImpl(String ownerName, Set modifiers, String name) { super(name, modifiers); myOwnerName = ownerName; } @NotNull @Override - public byte[] getOwnerName() { + public String getOwnerName() { return myOwnerName; } } abstract class JavacElementRefBase implements JavacRef { protected final @NotNull Element myOriginalElement; - protected final Elements myElementUtility; + protected final NameTableCache myNameTableCache; - protected JavacElementRefBase(@NotNull Element element, Elements elementUtility) { + protected JavacElementRefBase(@NotNull Element element, NameTableCache nameTableCache) { myOriginalElement = element; - myElementUtility = elementUtility; + myNameTableCache = nameTableCache; } @NotNull @@ -136,8 +134,8 @@ public interface JavacRef { @NotNull @Override - public byte[] getName() { - return ((Name) myOriginalElement.getSimpleName()).toUtf(); + public String getName() { + return myNameTableCache.get(myOriginalElement.getSimpleName()); } @Override @@ -147,44 +145,44 @@ public interface JavacRef { @NotNull @Override - public byte[] getOwnerName() { - return ((Name) myElementUtility.getBinaryName(((TypeElement) myOriginalElement.getEnclosingElement()))).toUtf(); + public String getOwnerName() { + return myNameTableCache.get(myNameTableCache.getBinaryName(myOriginalElement.getEnclosingElement())); } - public static JavacElementRefBase fromElement(Element element, Elements elementUtility) { + public static JavacElementRefBase fromElement(Element element, NameTableCache nameTableCache) { if (element instanceof TypeElement) { - return new JavacElementClassImpl(element, elementUtility); + return new JavacElementClassImpl(element, nameTableCache); } else if (element instanceof VariableElement) { - return new JavacElementFieldImpl(element, elementUtility); + return new JavacElementFieldImpl(element, nameTableCache); } else if (element instanceof ExecutableElement) { - return new JavacElementMethodImpl(element, elementUtility); + return new JavacElementMethodImpl(element, nameTableCache); } throw new AssertionError("unexpected element: " + element + " class: " + element.getClass()); } } class JavacElementClassImpl extends JavacElementRefBase implements JavacClass { - public JavacElementClassImpl(@NotNull Element element, Elements elementUtility) { - super(element, elementUtility); + public JavacElementClassImpl(@NotNull Element element, NameTableCache nameTableCache) { + super(element, nameTableCache); } @NotNull @Override - public byte[] getName() { - return ((Name) myElementUtility.getBinaryName(((TypeElement) myOriginalElement))).toUtf(); + public String getName() { + return myNameTableCache.get(myNameTableCache.getBinaryName(myOriginalElement)); } @Override public boolean isAnonymous() { - return ((Name) myOriginalElement.getSimpleName()).isEmpty(); + return myNameTableCache.get(myOriginalElement.getSimpleName()).isEmpty(); } } class JavacElementMethodImpl extends JavacElementRefBase implements JavacMethod { - public JavacElementMethodImpl(@NotNull Element element, Elements elementUtility) { - super(element, elementUtility); + public JavacElementMethodImpl(@NotNull Element element, NameTableCache nameTableCache) { + super(element, nameTableCache); } @Override @@ -194,8 +192,8 @@ public interface JavacRef { } class JavacElementFieldImpl extends JavacElementRefBase implements JavacField { - public JavacElementFieldImpl(@NotNull Element element, Elements elementUtility) { - super(element, elementUtility); + public JavacElementFieldImpl(@NotNull Element element, NameTableCache nameTableCache) { + super(element, nameTableCache); } } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/NameTableCache.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/NameTableCache.java new file mode 100644 index 000000000000..0ffcf53c2c95 --- /dev/null +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/NameTableCache.java @@ -0,0 +1,43 @@ +/* + * 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.javac.ast.api; + +import com.intellij.util.containers.SLRUCache; +import org.jetbrains.annotations.NotNull; + +import javax.lang.model.element.Element; +import javax.lang.model.element.Name; +import javax.lang.model.element.TypeElement; +import javax.lang.model.util.Elements; + +public class NameTableCache extends SLRUCache { + private final Elements myElements; + + public NameTableCache(Elements elements) { + super(1000, 1000); + myElements = elements; + } + + @NotNull + @Override + public String createValue(Name name) { + return name.toString(); + } + + public Name getBinaryName(Element element) { + return myElements.getBinaryName((TypeElement)element); + } +} diff --git a/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTestBase.kt b/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTestBase.kt index 131d2c7776a3..5dc1bb86ad66 100644 --- a/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTestBase.kt +++ b/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTestBase.kt @@ -22,9 +22,8 @@ import com.intellij.util.indexing.ID import com.intellij.util.indexing.impl.MapIndexStorage import com.intellij.util.indexing.impl.MapReduceIndex import com.intellij.util.io.PersistentStringEnumerator -import com.sun.tools.javac.util.Convert import org.jetbrains.jps.backwardRefs.BackwardReferenceIndexWriter -import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator +import org.jetbrains.jps.backwardRefs.NameEnumerator import org.jetbrains.jps.backwardRefs.CompilerBackwardReferenceIndex import org.jetbrains.jps.backwardRefs.LightRef import org.jetbrains.jps.backwardRefs.index.CompiledFileData @@ -175,13 +174,13 @@ abstract class ReferenceIndexTestBase : JpsBuildTestCase() { private fun getTestDataPath() = testDataRootPath + "/" + getTestName(true) + "/" - private fun Int.asName(byteArrayEnumerator: ByteArrayEnumerator): String = Convert.utf2string(byteArrayEnumerator.valueOf(this)) + private fun Int.asName(nameEnumerator: NameEnumerator): String = nameEnumerator.getName(this) - private fun LightRef.asText(byteArrayEnumerator: ByteArrayEnumerator): String = + private fun LightRef.asText(nameEnumerator: NameEnumerator): String = when (this) { - is LightRef.JavaLightMethodRef -> "${this.owner.name.asName(byteArrayEnumerator)}.${this.name.asName(byteArrayEnumerator)}(${this.parameterCount})" - is LightRef.JavaLightFieldRef -> "${this.owner.name.asName(byteArrayEnumerator)}.${this.name.asName(byteArrayEnumerator)}" - is LightRef.JavaLightClassRef -> this.name.asName(byteArrayEnumerator) + is LightRef.JavaLightMethodRef -> "${this.owner.name.asName(nameEnumerator)}.${this.name.asName(nameEnumerator)}(${this.parameterCount})" + is LightRef.JavaLightFieldRef -> "${this.owner.name.asName(nameEnumerator)}.${this.name.asName(nameEnumerator)}" + is LightRef.JavaLightClassRef -> this.name.asName(nameEnumerator) is LightRef.JavaLightFunExprDef -> "fun_expr(id=${this.id})" else -> throw UnsupportedOperationException() }