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

stub hierarchy: occupy less memory in ClassSymbol objects

Browse Source
This commit is contained in:
peter
2016-06-24 17:59:56 +02:00
parent ac051a0733
commit b692afe020
5 changed files with 41 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/StubEnter.java
+3 -3
View File
@@ -88,7 +88,7 @@ public class StubEnter {
supers = myNameEnvironment.annotation;
}
ClassSymbol classSymbol = mySymbols.enterClass(tree.myClassAnchor, flags, tree.myName, owner, info, supers, myStubHierarchyConnector);
ClassSymbol classSymbol = mySymbols.enterClass(tree.myClassAnchor, flags, tree.myName, owner, info, supers);
if (uncompleted != null) {
uncompleted.add(classSymbol);
@@ -100,14 +100,14 @@ public class StubEnter {
public void connect1() {
for (ClassSymbol classSymbol : uncompleted) {
classSymbol.connect();
classSymbol.connect(myStubHierarchyConnector);
}
uncompleted = new ArrayList<ClassSymbol>();
}
public void connect2() {
for (ClassSymbol classSymbol : uncompleted) {
classSymbol.connect();
classSymbol.connect(myStubHierarchyConnector);
}
uncompleted = null;
}
java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/StubHierarchyConnector.java
+3 -2
View File
@@ -26,14 +26,14 @@ public class StubHierarchyConnector {
protected StubHierarchyConnector(NameEnvironment nameEnvironment, Symbols symbols) {
this.myNameEnvironment = nameEnvironment;
myResolve = new StubResolver(symbols);
myResolve = new StubResolver(symbols, this);
}
void connect(Symbol sym) {
Symbol.ClassSymbol c = (Symbol.ClassSymbol) sym;
if (c.myOwner instanceof Symbol.ClassSymbol) {
((Symbol.ClassSymbol)c.myOwner).connect();
((Symbol.ClassSymbol)c.myOwner).connect(this);
}
// Determine supertype.
@@ -67,6 +67,7 @@ public class StubHierarchyConnector {
c.mySuperClasses = Symbol.ClassSymbol.EMPTY_ARRAY;
}
else {
//noinspection SuspiciousToArrayCall
c.mySuperClasses = supertypes.toArray(new Symbol.ClassSymbol[supertypes.size()]);
}
}
java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/StubResolver.java
+8 -6
View File
@@ -28,10 +28,12 @@ import java.util.Set;
public class StubResolver {
private final Symbols mySymbols;
private final NameEnvironment myNameEnvironment;
private final StubHierarchyConnector myConnector;
public StubResolver(Symbols symbols) {
public StubResolver(Symbols symbols, StubHierarchyConnector connector) {
this.mySymbols = symbols;
this.myNameEnvironment = symbols.myNameEnvironment;
myConnector = connector;
}
// resolve class `sym` extends/implements `baseId`
@@ -97,7 +99,7 @@ public class StubResolver {
}
}
private static void findMemberType(Symbol s, int name, Set<Symbol> symbols, Set<Symbol> processed) throws IncompleteHierarchyException {
private void findMemberType(Symbol s, int name, Set<Symbol> symbols, Set<Symbol> processed) throws IncompleteHierarchyException {
if (!processed.add(s)) {
return;
}
@@ -130,9 +132,9 @@ public class StubResolver {
}
}
private static void findInheritedMemberType(Symbol.ClassSymbol c, int name, Set<Symbol> symbols, Set<Symbol> processed)
private void findInheritedMemberType(Symbol.ClassSymbol c, int name, Set<Symbol> symbols, Set<Symbol> processed)
throws IncompleteHierarchyException {
for (Symbol.ClassSymbol st : c.getSuperClasses())
for (Symbol.ClassSymbol st : c.getSuperClasses(myConnector))
findMemberType(st, name, symbols, processed);
}
@@ -194,13 +196,13 @@ public class StubResolver {
}
// handling of import static `tsym.name` as
private static void importNamedStatic(final Symbol.ClassSymbol tsym, final int name, final Set<Symbol> symbols) throws IncompleteHierarchyException {
private void importNamedStatic(final Symbol.ClassSymbol tsym, final int name, final Set<Symbol> symbols) throws IncompleteHierarchyException {
new Object() {
Set<Symbol> processed = new HashSet<Symbol>();
void importFrom(Symbol.ClassSymbol cs) throws IncompleteHierarchyException {
if (cs == null || !processed.add(cs))
return;
for (Symbol.ClassSymbol c : cs.getSuperClasses())
for (Symbol.ClassSymbol c : cs.getSuperClasses(myConnector))
importFrom(c);
importMember(cs.members(), name, symbols, true);
}
java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/Symbol.java
+25 -23
View File
@@ -86,28 +86,27 @@ public abstract class Symbol {
/** A class for class symbols
*/
public static class ClassSymbol extends Symbol {
private static final int HIERARCHY_INCOMPLETE = 1 << 20;
private static final int CONNECT_STARTED = 1 << 21;
public static final ClassSymbol[] EMPTY_ARRAY = new ClassSymbol[0];
public final StubClassAnchor myClassAnchor;
public ClassSymbol[] mySuperClasses;
public UnitInfo myUnitInfo;
public QualifiedName[] mySuperNames;
private ClassSymbol[] myMembers;
private StubHierarchyConnector myConnector;
private boolean myHierarchyIncomplete;
public ClassSymbol(StubClassAnchor classAnchor,
final StubClassAnchor myClassAnchor;
ClassSymbol[] mySuperClasses;
UnitInfo myUnitInfo;
QualifiedName[] mySuperNames;
private ClassSymbol[] myMembers;
ClassSymbol(StubClassAnchor classAnchor,
int flags,
Symbol owner,
QualifiedName fullname,
int name,
UnitInfo unitInfo,
QualifiedName[] supers,
StubHierarchyConnector connector) {
QualifiedName[] supers) {
super(flags | IndexTree.CLASS, owner, fullname, name);
this.myClassAnchor = classAnchor;
this.mySuperNames = supers;
this.myUnitInfo = unitInfo;
this.myConnector = connector;
}
@Override
@@ -115,18 +114,21 @@ public abstract class Symbol {
return myClassAnchor.toString();
}
public void connect() {
if (myConnector != null) {
StubHierarchyConnector c = myConnector;
myConnector = null;
c.connect(this);
void connect(StubHierarchyConnector connector) {
if (!isConnectStarted()) {
myFlags = BitUtil.set(myFlags, CONNECT_STARTED, true);
connector.connect(this);
}
}
private boolean isConnectStarted() {
return BitUtil.isSet(myFlags, CONNECT_STARTED);
}
@NotNull
public ClassSymbol[] getSuperClasses() throws IncompleteHierarchyException {
connect();
if (myHierarchyIncomplete) {
ClassSymbol[] getSuperClasses(StubHierarchyConnector connector) throws IncompleteHierarchyException {
connect(connector);
if (isHierarchyIncomplete()) {
throw IncompleteHierarchyException.INSTANCE;
}
return rawSuperClasses();
@@ -134,11 +136,11 @@ public abstract class Symbol {
@NotNull
ClassSymbol[] rawSuperClasses() {
assert myConnector == null;
assert isConnectStarted();
return mySuperClasses == null ? EMPTY_ARRAY : mySuperClasses;
}
public boolean isCompiled() {
boolean isCompiled() {
return BitUtil.isSet(myFlags, IndexTree.COMPILED);
}
@@ -154,11 +156,11 @@ public abstract class Symbol {
mySuperClasses = EMPTY_ARRAY;
mySuperNames = null;
myUnitInfo = null;
myHierarchyIncomplete = true;
myFlags = BitUtil.set(myFlags, HIERARCHY_INCOMPLETE, true);
}
boolean isHierarchyIncomplete() {
return myHierarchyIncomplete;
return BitUtil.isSet(myFlags, HIERARCHY_INCOMPLETE);
}
boolean hasAmbiguousSupers() {
java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/Symbols.java
+2 -2
View File
@@ -63,10 +63,10 @@ public class Symbols {
return (ClassSymbol[])cs;
}
public ClassSymbol enterClass(ClassAnchor classAnchor, int flags, int shortName, Symbol owner, UnitInfo info, QualifiedName[] supers, StubHierarchyConnector connector) {
public ClassSymbol enterClass(ClassAnchor classAnchor, int flags, int shortName, Symbol owner, UnitInfo info, QualifiedName[] supers) {
QualifiedName qualifiedName = myNameEnvironment.qualifiedName(owner, shortName);
StubClassAnchor stubClassAnchor = new StubClassAnchor(myClassSymbols.size(), classAnchor);
ClassSymbol c = new ClassSymbol(stubClassAnchor, flags, owner, qualifiedName, shortName, info, supers, connector);
ClassSymbol c = new ClassSymbol(stubClassAnchor, flags, owner, qualifiedName, shortName, info, supers);
myClassSymbols.add(c);
putClassByName(c);
return c;