From 0b4d013e9483832b8826410d7aab7340dcd9c1fc Mon Sep 17 00:00:00 2001 From: Maxim Shafirov Date: Thu, 8 Dec 2011 15:56:09 +0400 Subject: [PATCH] JavaElementFinder now returns light classes, that use compiler on demand only --- .../resolve/java/JetJavaMirrorMarker.java | 9 + .../jet/plugin/java/JavaElementFinder.java | 190 +++++------------- .../jet/plugin/java/JetLightClass.java | 152 ++++++++++++++ 3 files changed, 212 insertions(+), 139 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetJavaMirrorMarker.java create mode 100644 idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetJavaMirrorMarker.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetJavaMirrorMarker.java new file mode 100644 index 00000000000..50751d555b0 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetJavaMirrorMarker.java @@ -0,0 +1,9 @@ +/* + * @author max + */ +package org.jetbrains.jet.lang.resolve.java; + +import com.intellij.psi.PsiClass; + +public interface JetJavaMirrorMarker extends PsiClass { +} diff --git a/idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java b/idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java index 78b31e8fad6..3cfc18e96b0 100644 --- a/idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java +++ b/idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java @@ -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 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 answer = new SmartList(); - final List 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 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 answer = new HashSet(); 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 psiFiles = collectProjectFiles(project, GlobalSearchScope.allScope(project)); + final List 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 answer = new SmartList(); - final List 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 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 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 ensureUpToDate(GlobalSearchScope scope) { - final Stack stubStack = new Stack(); - - 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 psiFiles = collectProjectFiles(project, scope); - - Collection dirty = Collections2.filter(psiFiles, new Predicate() { - @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 collectProjectFiles(final Project project, @NotNull final GlobalSearchScope scope) { - final List answer = new ArrayList(); + private static List collectProjectFiles(final Project project, @NotNull final GlobalSearchScope scope) { + final List answer = new ArrayList(); 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); } } } diff --git a/idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java b/idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java new file mode 100644 index 00000000000..561e98b164c --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java @@ -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 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 stubStack = new Stack(); + + 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 files = Collections.singletonList(file); + final BindingContext context = AnalyzerFacade.shallowAnalyzeFiles(files); + state.compileCorrectNamespaces(context, AnalyzerFacade.collectRootNamespaces(files)); + state.getFactory().files(); + + return answer; + } + +}