azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

JavaElementFinder now returns light classes, that use compiler on demand only

Browse Source
This commit is contained in:
Maxim Shafirov
2011-12-08 15:56:09 +04:00
parent a0cd4af3bd
commit 0b4d013e94
3 changed files with 212 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetJavaMirrorMarker.java
+9
View File
@@ -0,0 +1,9 @@
/*
* @author max
*/
package org.jetbrains.jet.lang.resolve.java;
import com.intellij.psi.PsiClass;
public interface JetJavaMirrorMarker extends PsiClass {
}
idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java
+51 -139
View File
@@ -3,55 +3,39 @@
*/
package org.jetbrains.jet.plugin.java;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.intellij.openapi.compiler.ex.CompilerPathsEx;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ProjectRootManager;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiManagerImpl;
import com.intellij.psi.impl.compiled.ClsFileImpl;
import com.intellij.psi.impl.file.PsiPackageImpl;
import com.intellij.psi.impl.java.stubs.PsiClassStub;
import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.stubs.PsiClassHolderFileStub;
import com.intellij.psi.stubs.StubElement;
import com.intellij.util.SmartList;
import com.intellij.util.containers.Stack;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.codegen.ClassBuilder;
import org.jetbrains.jet.codegen.ClassBuilderFactory;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.lang.psi.JetClassOrObject;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
import org.jetbrains.jet.plugin.JetFileType;
import java.util.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class JavaElementFinder extends PsiElementFinder {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.plugin.java.JavaElementFinder");
private final Project project;
private final PsiManager psiManager;
public JavaElementFinder(Project project) {
this.project = project;
psiManager = PsiManager.getInstance(project);
}
private final static Key<PsiJavaFileStub> JAVA_API_STUB = Key.create("JAVA_API_STUB");
@Override
public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) {
final PsiClass[] allClasses = findClasses(qualifiedName, scope);
@@ -65,14 +49,22 @@ public class JavaElementFinder extends PsiElementFinder {
if (qualifiedName.startsWith("java.")) return PsiClass.EMPTY_ARRAY;
List<PsiClass> answer = new SmartList<PsiClass>();
final List<PsiFile> filesInScope = ensureUpToDate(scope);
for (PsiFile file : filesInScope) {
final PsiJavaFileStub stub = file.getUserData(JAVA_API_STUB);
if (stub == null) continue;
final String packageName = stub.getPackageName();
final List<JetFile> filesInScope = collectProjectFiles(project, scope);
for (JetFile file : filesInScope) {
JetNamespace rootNamespace = file.getRootNamespace();
final String packageName = CodegenUtil.getFQName(rootNamespace);
if (packageName != null && qualifiedName.startsWith(packageName)) {
collectClasses(answer, qualifiedName, stub);
if (qualifiedName.equals(fqn(packageName, "namespace"))) {
answer.add(new JetLightClass(psiManager, file, "namespace"));
}
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
if (qualifiedName.equals(fqn(packageName, declaration.getName()))) {
answer.add(new JetLightClass(psiManager, file, declaration.getName()));
}
}
}
}
}
return answer.toArray(new PsiClass[answer.size()]);
@@ -83,15 +75,13 @@ public class JavaElementFinder extends PsiElementFinder {
Set<String> answer = new HashSet<String>();
String packageFQN = psiPackage.getQualifiedName();
for (PsiFile psiFile : collectProjectFiles(project, GlobalSearchScope.allScope(project))) {
if (psiFile instanceof JetFile) {
final JetNamespace rootNamespace = ((JetFile) psiFile).getRootNamespace();
if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
answer.add("namespace");
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
answer.add(declaration.getName());
}
for (JetFile psiFile : collectProjectFiles(project, GlobalSearchScope.allScope(project))) {
final JetNamespace rootNamespace = psiFile.getRootNamespace();
if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
answer.add("namespace");
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
answer.add(declaration.getName());
}
}
}
@@ -100,15 +90,18 @@ public class JavaElementFinder extends PsiElementFinder {
return answer;
}
private static String fqn(String packageName, String className) {
if (StringUtil.isEmpty(packageName)) return className;
return packageName + "." + className;
}
@Override
public PsiPackage findPackage(@NotNull String qualifiedName) {
final List<PsiFile> psiFiles = collectProjectFiles(project, GlobalSearchScope.allScope(project));
final List<JetFile> psiFiles = collectProjectFiles(project, GlobalSearchScope.allScope(project));
for (PsiFile psiFile : psiFiles) {
if (psiFile instanceof JetFile) {
if (qualifiedName.equals(CodegenUtil.getFQName(((JetFile) psiFile).getRootNamespace()))) {
return new PsiPackageImpl(psiFile.getManager(), qualifiedName);
}
for (JetFile psiFile : psiFiles) {
if (qualifiedName.equals(CodegenUtil.getFQName(psiFile.getRootNamespace()))) {
return new PsiPackageImpl(psiFile.getManager(), qualifiedName);
}
}
@@ -119,107 +112,26 @@ public class JavaElementFinder extends PsiElementFinder {
@Override
public PsiClass[] getClasses(@NotNull PsiPackage psiPackage, @NotNull GlobalSearchScope scope) {
List<PsiClass> answer = new SmartList<PsiClass>();
final List<PsiFile> filesInScope = ensureUpToDate(scope);
final String qualifiedName = psiPackage.getQualifiedName();
for (PsiFile file : filesInScope) {
final PsiJavaFileStub stub = file.getUserData(JAVA_API_STUB);
if (stub == null) continue;
if (Comparing.equal(qualifiedName, stub.getPackageName())) {
for (StubElement child : stub.getChildrenStubs()) {
if (child instanceof PsiClassStub) {
answer.add((PsiClass) child.getPsi());
final List<JetFile> filesInScope = collectProjectFiles(project, scope);
String packageFQN = psiPackage.getQualifiedName();
for (JetFile file : filesInScope) {
final JetNamespace rootNamespace = file.getRootNamespace();
if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
answer.add(new JetLightClass(psiManager, file, "namespace"));
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
answer.add(new JetLightClass(psiManager, file, declaration.getName()));
}
}
}
}
return answer.toArray(new PsiClass[answer.size()]);
}
private static void collectClasses(List<PsiClass> answer, String qualifiedName, StubElement<?> stub) {
if (stub instanceof PsiClassStub && qualifiedName.equals(((PsiClassStub) stub).getQualifiedName())) {
answer.add((PsiClass) stub.getPsi());
}
for (StubElement child : stub.getChildrenStubs()) {
collectClasses(answer, qualifiedName, child);
}
}
private List<PsiFile> ensureUpToDate(GlobalSearchScope scope) {
final Stack<StubElement> stubStack = new Stack<StubElement>();
final ClassBuilderFactory builderFactory = new ClassBuilderFactory() {
@Override
public ClassBuilder newClassBuilder() {
return new StubClassBuilder(stubStack);
}
@Override
public String asText(ClassBuilder builder) {
throw new UnsupportedOperationException("asText is not implemented"); // TODO
}
@Override
public byte[] asBytes(ClassBuilder builder) {
throw new UnsupportedOperationException("asBytes is not implemented"); // TODO
}
};
final GenerationState state = new GenerationState(project, builderFactory) {
@Override
protected void generateNamespace(JetNamespace namespace) {
final PsiJavaFileStubImpl fileStub = new PsiJavaFileStubImpl(CodegenUtil.getFQName(namespace), true);
PsiManager manager = PsiManager.getInstance(project);
stubStack.push(fileStub);
final PsiFile file = namespace.getContainingFile();
file.putUserData(JAVA_API_STUB, fileStub);
fileStub.setPsiFactory(new ClsWrapperStubPsiFactory());
final ClsFileImpl fakeFile = new ClsFileImpl((PsiManagerImpl) manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
@NotNull
@Override
public PsiClassHolderFileStub getStub() {
return fileStub;
}
};
fakeFile.setPhysical(false);
fileStub.setPsi(fakeFile);
try {
super.generateNamespace(namespace);
}
finally {
final StubElement pop = stubStack.pop();
if (pop != fileStub) {
LOG.error("Unbalanced stack operations");
}
}
}
};
final List<PsiFile> psiFiles = collectProjectFiles(project, scope);
Collection<PsiFile> dirty = Collections2.filter(psiFiles, new Predicate<PsiFile>() {
@Override
public boolean apply(PsiFile psiFile) {
return psiFile.getUserData(JAVA_API_STUB) == null;
}
});
if (dirty.size() > 0) {
final BindingContext context = AnalyzerFacade.shallowAnalyzeFiles(dirty);
state.compileCorrectNamespaces(context, AnalyzerFacade.collectRootNamespaces(dirty));
state.getFactory().files();
}
return psiFiles;
}
private static List<PsiFile> collectProjectFiles(final Project project, @NotNull final GlobalSearchScope scope) {
final List<PsiFile> answer = new ArrayList<PsiFile>();
private static List<JetFile> collectProjectFiles(final Project project, @NotNull final GlobalSearchScope scope) {
final List<JetFile> answer = new ArrayList<JetFile>();
final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
@@ -235,7 +147,7 @@ public class JavaElementFinder extends PsiElementFinder {
if (scope.accept(file)) {
final PsiFile psiFile = psiManager.findFile(file);
if (psiFile instanceof JetFile) {
answer.add(psiFile);
answer.add((JetFile) psiFile);
}
}
}
idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java
+152
View File
@@ -0,0 +1,152 @@
/*
* @author max
*/
package org.jetbrains.jet.plugin.java;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Key;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiManagerImpl;
import com.intellij.psi.impl.compiled.ClsFileImpl;
import com.intellij.psi.impl.java.stubs.PsiClassStub;
import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
import com.intellij.psi.impl.light.AbstractLightClass;
import com.intellij.psi.stubs.PsiClassHolderFileStub;
import com.intellij.psi.stubs.StubElement;
import com.intellij.util.containers.Stack;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.codegen.ClassBuilder;
import org.jetbrains.jet.codegen.ClassBuilderFactory;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
import org.jetbrains.jet.plugin.JetLanguage;
import java.util.Collections;
import java.util.List;
public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMarker {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.plugin.java.JetLightClass");
private final static Key<PsiJavaFileStub> JAVA_API_STUB = Key.create("JAVA_API_STUB");
private final JetFile file;
private final String className;
private PsiClass delegate;
public JetLightClass(PsiManager manager, JetFile file, String className) {
super(manager, JetLanguage.INSTANCE);
this.file = file;
this.className = className;
}
@Override
public String getName() {
return className;
}
@Override
public PsiElement copy() {
return new JetLightClass(getManager(), file, className);
}
@Override
public PsiClass getDelegate() {
if (delegate == null) {
delegate = findClass(className, getStub());
}
return delegate;
}
private static PsiClass findClass(String name, StubElement<?> stub) {
if (stub instanceof PsiClassStub && name.equals(((PsiClassStub) stub).getName())) {
return (PsiClass) stub.getPsi();
}
for (StubElement child : stub.getChildrenStubs()) {
PsiClass answer = findClass(name, child);
if (answer != null) return answer;
}
return null;
}
private PsiJavaFileStub getStub() {
PsiJavaFileStub answer = file.getUserData(JAVA_API_STUB);
if (answer == null) {
answer = calcStub();
file.putUserData(JAVA_API_STUB, answer);
}
return answer;
}
private PsiJavaFileStub calcStub() {
final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(CodegenUtil.getFQName(file.getRootNamespace()), true);
final Project project = getProject();
final Stack<StubElement> stubStack = new Stack<StubElement>();
final ClassBuilderFactory builderFactory = new ClassBuilderFactory() {
@Override
public ClassBuilder newClassBuilder() {
return new StubClassBuilder(stubStack);
}
@Override
public String asText(ClassBuilder builder) {
throw new UnsupportedOperationException("asText is not implemented"); // TODO
}
@Override
public byte[] asBytes(ClassBuilder builder) {
throw new UnsupportedOperationException("asBytes is not implemented"); // TODO
}
};
final GenerationState state = new GenerationState(project, builderFactory) {
@Override
protected void generateNamespace(JetNamespace namespace) {
PsiManager manager = PsiManager.getInstance(project);
stubStack.push(answer);
answer.setPsiFactory(new ClsWrapperStubPsiFactory());
final ClsFileImpl fakeFile = new ClsFileImpl((PsiManagerImpl) manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
@NotNull
@Override
public PsiClassHolderFileStub getStub() {
return answer;
}
};
fakeFile.setPhysical(false);
answer.setPsi(fakeFile);
try {
super.generateNamespace(namespace);
}
finally {
final StubElement pop = stubStack.pop();
if (pop != answer) {
LOG.error("Unbalanced stack operations");
}
}
}
};
List<PsiFile> files = Collections.<PsiFile>singletonList(file);
final BindingContext context = AnalyzerFacade.shallowAnalyzeFiles(files);
state.compileCorrectNamespaces(context, AnalyzerFacade.collectRootNamespaces(files));
state.getFactory().files();
return answer;
}
}