diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java deleted file mode 100644 index d5411bf86bf..00000000000 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java +++ /dev/null @@ -1,312 +0,0 @@ -/* - * Copyright 2010-2012 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.jet.asJava; - -import com.intellij.navigation.ItemPresentation; -import com.intellij.navigation.ItemPresentationProviders; -import com.intellij.openapi.progress.ProcessCanceledException; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Comparing; -import com.intellij.openapi.util.Key; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.*; -import com.intellij.psi.impl.PsiClassImplUtil; -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.StubElement; -import com.intellij.psi.util.*; -import com.intellij.util.containers.Stack; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.codegen.*; -import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; -import org.jetbrains.jet.codegen.state.GenerationState; -import org.jetbrains.jet.codegen.state.GenerationStrategy; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; -import org.jetbrains.jet.lang.resolve.java.JvmClassName; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.plugin.JetLanguage; - -import javax.swing.*; -import java.util.Collections; - -@Deprecated -public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMarker { - static class JetBadWrapperException extends RuntimeException { - private final String context; - - public JetBadWrapperException(@Nullable Exception exc, @NotNull JetNamedDeclaration originalElement, PsiElement wrappedElement) { - super("Error while wrapping function " + originalElement.getName(), exc); - context = String.format("=== In file ===\n" + - "%s\n" + - "===On element===\n" + - "%s\n" + - "===WrappedElement===\n" + - "%s\n", - originalElement.getContainingFile().getText(), - originalElement.getText(), - wrappedElement.toString()); - } - - @Override - public String toString() { - return super.toString() + "\nContext:\n" + context; - } - } - - private final static Key> JAVA_API_STUB = Key.create("JAVA_API_STUB"); - - private final JetFile file; - private final FqName qualifiedName; - private PsiClass delegate; - - private JetLightClass(PsiManager manager, JetFile file, FqName qualifiedName) { - super(manager, JetLanguage.INSTANCE); - this.file = file; - this.qualifiedName = qualifiedName; - } - - @Nullable - public static JetLightClass create(@NotNull PsiManager manager, @NotNull JetFile file, @NotNull FqName qualifiedName) { - if (LightClassUtil.belongsToKotlinBuiltIns(file)) { - return null; - } - return new JetLightClass(manager, file, qualifiedName); - } - - @Override - public String getName() { - return qualifiedName.shortName().getName(); - } - - @NotNull - @Override - public PsiElement copy() { - JetLightClass result = create(getManager(), file, qualifiedName); - assert result != null; - return result; - } - - @NotNull - @Override - public PsiClass getDelegate() { - if (delegate == null) { - delegate = LightClassUtil.findClass(qualifiedName, getStub()); - if (delegate == null) { - throw new IllegalStateException("Class not found for qualified name: " + qualifiedName); - } - } - return delegate; - } - - @Override - public PsiFile getContainingFile() { - return file; - } - - @Override - public String getQualifiedName() { - return qualifiedName.getFqName(); - } - - public FqName getFqName() { - return qualifiedName; - } - - private PsiJavaFileStub getStub() { - CachedValue answer = file.getUserData(JAVA_API_STUB); - if (answer == null) { - answer = CachedValuesManager.getManager(getProject()).createCachedValue(new CachedValueProvider() { - @Override - public Result compute() { - //System.out.println("Calculating Java stub for " + file.getName() + ", OOCB modcount " + PsiModificationTracker.SERVICE.getInstance(getProject()).getOutOfCodeBlockModificationCount()); - return Result.create(calcStub(), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT); - } - }, false); - file.putUserData(JAVA_API_STUB, answer); - } - - return answer.getValue(); - } - - private PsiJavaFileStub calcStub() { - if (LightClassUtil.belongsToKotlinBuiltIns(file)) { - // We may not fail later due to some luck, but generating JetLightClasses for built-ins is a bad idea anyways - // If it fails later, there will be an exception logged - LightClassUtil.logErrorWithOSInfo(null, qualifiedName, file.getVirtualFile()); - } - - final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(JetPsiUtil.getFQName(file).getFqName(), true); - final Project project = getProject(); - - final Stack stubStack = new Stack(); - - final ClassBuilderFactory builderFactory = new ClassBuilderFactory() { - @NotNull - @Override - public ClassBuilderMode getClassBuilderMode() { - return ClassBuilderMode.SIGNATURES; - } - - @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 - } - }; - - // The context must reflect _all files in the module_. not only the current file - // Otherwise, the analyzer gets confused and can't, for example, tell which files come as sources and which - // must be loaded from .class files - LightClassConstructionContext context = LightClassGenerationSupport.getInstance(project).analyzeRelevantCode(Collections.singletonList(file)); - - Throwable error = context.getError(); - if (error != null) { - throw new IllegalStateException("failed to analyze: " + error, error); - } - - try { - GenerationState state = new GenerationState(project, builderFactory, context.getBindingContext(), Collections.singletonList(file)); - VirtualFile virtualFile = file.getVirtualFile(); - assert virtualFile != null; - - GenerationStrategy strategy = new LightClassGenerationStrategy(virtualFile, stubStack, answer); - KotlinCodegenFacade.compileCorrectFiles(state, strategy, CompilationErrorHandler.THROW_EXCEPTION); - - state.getFactory().files(); - } - catch (ProcessCanceledException e) { - throw e; - } - catch (RuntimeException e) { - LightClassUtil.logErrorWithOSInfo(e, qualifiedName, file.getVirtualFile()); - throw e; - } - - return answer; - } - - @Override - public boolean isEquivalentTo(PsiElement another) { - return another instanceof PsiClass && Comparing.equal(((PsiClass)another).getQualifiedName(), getQualifiedName()); - } - - @Override - public ItemPresentation getPresentation() { - return ItemPresentationProviders.getItemPresentation(this); - } - - @Override - public Icon getElementIcon(final int flags) { - return PsiClassImplUtil.getClassIcon(flags, this); - } - - @Override - public String toString() { - try { - return JetLightClass.class.getSimpleName() + ":" + getQualifiedName(); - } - catch (Throwable e) { - return JetLightClass.class.getSimpleName() + ":" + e.toString(); - } - } - - @Override - public int hashCode() { - int result = getManager().hashCode(); - result = 31 * result + file.hashCode(); - result = 31 * result + qualifiedName.hashCode(); - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) return true; - if (obj == null || getClass() != obj.getClass()) { - return false; - } - - JetLightClass lightClass = (JetLightClass) obj; - - if (getManager() != lightClass.getManager()) return false; - if (!file.equals(lightClass.file)) return false; - if (!qualifiedName.equals(lightClass.qualifiedName)) return false; - - return true; - } - - @Nullable - public static JetLightClass wrapDelegate(@Nullable JetClass jetClass) { - if (jetClass == null) { - return null; - } - - return wrapDelegate(jetClass, PsiCodegenPredictor.getPredefinedJvmClassName(jetClass)); - } - - @Nullable - private static JetLightClass wrapDelegate(@NotNull JetDeclaration declaration, @Nullable JvmClassName jvmClassName) { - if (jvmClassName == null) { - return null; - } - - return create(declaration.getManager(), (JetFile) declaration.getContainingFile(), jvmClassName.getFqName()); - } - - @Nullable - public static PsiMethod wrapMethod(@NotNull JetNamedFunction function) { - //noinspection unchecked - if (PsiTreeUtil.getParentOfType(function, JetFunction.class, JetProperty.class) != null) { - // Don't genClassOrObject method wrappers for internal declarations. Their classes are not generated during calcStub - // with ClassBuilderMode.SIGNATURES mode, and this produces "Class not found exception" in getDelegate() - return null; - } - - JetLightClass wrapper = wrapDelegate(function, PsiCodegenPredictor.getPredefinedJvmClassNameForFun(function)); - if (wrapper == null) { - return null; - } - - for (PsiMethod method : wrapper.getMethods()) { - try { - if (method instanceof PsiCompiledElement && ((PsiCompiledElement) method).getMirror() == function) { - return method; - } - } - catch (Exception exception) { - throw new JetBadWrapperException(exception, function, method); - } - } - - return null; - } - - public JetFile getFile() { - return file; - } -} diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClass.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClass.java index b0793534aab..98ec6cf4e7b 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClass.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClass.java @@ -23,4 +23,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName; public interface KotlinLightClass extends PsiClass { @NotNull FqName getFqName(); + + @NotNull + PsiClass getDelegate(); } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java index 5fef33db891..e0a0e95cced 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java @@ -17,16 +17,24 @@ package org.jetbrains.jet.asJava; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.progress.ProcessCanceledException; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiCompiledElement; +import com.intellij.psi.PsiMethod; import com.intellij.psi.impl.java.stubs.PsiClassStub; +import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.stubs.PsiFileStub; import com.intellij.psi.stubs.StubElement; +import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.utils.KotlinVfsUtil; @@ -85,8 +93,6 @@ public class LightClassUtil { cause); } - private LightClassUtil() {} - @Nullable /*package*/ static PsiClass findClass(@NotNull FqName fqn, @NotNull StubElement stub) { if (stub instanceof PsiClassStub && Comparing.equal(fqn.getFqName(), ((PsiClassStub) stub).getQualifiedName())) { @@ -102,4 +108,63 @@ public class LightClassUtil { return null; } + + @Nullable + public static KotlinLightClass createLightClass(@Nullable JetClassOrObject classOrObject) { + if (classOrObject == null) return null; + + JvmClassName jvmClassName = PsiCodegenPredictor.getPredefinedJvmClassName(classOrObject); + if (jvmClassName == null) return null; + + return KotlinLightClassForExplicitDeclaration.create(classOrObject.getManager(), jvmClassName.getFqName(), classOrObject); + } + + @Nullable + public static PsiMethod getLightClassMethod(@NotNull JetNamedFunction function) { + //noinspection unchecked + if (PsiTreeUtil.getParentOfType(function, JetFunction.class, JetProperty.class) != null) { + // Don't genClassOrObject method wrappers for internal declarations. Their classes are not generated during calcStub + // with ClassBuilderMode.SIGNATURES mode, and this produces "Class not found exception" in getDelegate() + return null; + } + + Project project = function.getProject(); + JvmClassName jvmClassName = PsiCodegenPredictor.getPredefinedJvmClassNameForFun(function); + if (jvmClassName == null) return null; + + String fqName = jvmClassName.getFqName().getFqName(); + PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName, GlobalSearchScope.allScope(project)); + if (psiClass == null) return null; + + for (PsiMethod method : psiClass.getMethods()) { + try { + if (method instanceof PsiCompiledElement && ((PsiCompiledElement) method).getMirror() == function) { + return method; + } + } + catch (ProcessCanceledException e) { + throw e; + } + catch (Throwable e) { + throw new IllegalStateException( + "Error while wrapping function " + function.getName() + + "Context\n:" + + String.format("=== In file ===\n" + + "%s\n" + + "===On element===\n" + + "%s\n" + + "===WrappedElement===\n" + + "%s\n", + function.getContainingFile().getText(), + function.getText(), + method.toString()), + e + ); + } + } + + return null; + } + + private LightClassUtil() {} } diff --git a/idea/src/org/jetbrains/jet/plugin/JetGotoTargetRenderProvider.java b/idea/src/org/jetbrains/jet/plugin/JetGotoTargetRenderProvider.java index d0695a4ced4..088eaed1163 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetGotoTargetRenderProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetGotoTargetRenderProvider.java @@ -21,14 +21,14 @@ import com.intellij.codeInsight.navigation.GotoTargetRendererProvider; import com.intellij.ide.util.PsiElementListCellRenderer; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.plugin.presentation.JetLightClassListCellRenderer; public class JetGotoTargetRenderProvider implements GotoTargetRendererProvider { @Nullable @Override public PsiElementListCellRenderer getRenderer(PsiElement element, GotoTargetHandler.GotoData gotoData) { - if (element instanceof JetLightClass) { + if (element instanceof KotlinLightClass) { // Need to override default Java render return new JetLightClassListCellRenderer(); } diff --git a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java index b694c9aaf9e..fd4e0411b9e 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java @@ -27,7 +27,6 @@ import com.intellij.util.PlatformIcons; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration; import org.jetbrains.jet.asJava.KotlinLightClassForPackage; import org.jetbrains.jet.lang.psi.*; @@ -157,10 +156,6 @@ public class JetIconProvider extends IconProvider { return property.isVar() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL; } - if (psiElement instanceof JetLightClass) { - return JetIcons.CLASS; - } - return null; } } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java b/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java index 9c16dd0d015..b6bf0110826 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java @@ -22,7 +22,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiClass; import com.intellij.util.Consumer; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -82,7 +82,7 @@ public class JetTypesCompletionHelper { } private static boolean addJavaClassAsJetLookupElement(PsiClass aClass, JetCompletionResultSet jetCompletionResult) { - if (aClass instanceof JetLightClass) { + if (aClass instanceof KotlinLightClass) { // Do nothing. Kotlin not-compiled class should have already been added as kotlin element before. return true; } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index 08328628808..ce5d912b1c0 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -37,7 +37,8 @@ import com.intellij.ui.awt.RelativePoint; import com.intellij.util.Function; import com.intellij.util.PsiNavigateUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.Modality; @@ -79,7 +80,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { return null; } } - JetLightClass lightClass = JetLightClass.wrapDelegate((JetClass) element); + KotlinLightClass lightClass = LightClassUtil.createLightClass((JetClass) element); if (lightClass == null) { return null; } @@ -251,7 +252,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { if (!element.hasModifier(JetTokens.OPEN_KEYWORD)) { return; } - JetLightClass lightClass = JetLightClass.wrapDelegate(element); + PsiClass lightClass = LightClassUtil.createLightClass(element); if (lightClass == null) { return; } diff --git a/idea/src/org/jetbrains/jet/plugin/presentation/JetLightClassListCellRenderer.java b/idea/src/org/jetbrains/jet/plugin/presentation/JetLightClassListCellRenderer.java index ef049a230f7..9a1dd0c0d31 100644 --- a/idea/src/org/jetbrains/jet/plugin/presentation/JetLightClassListCellRenderer.java +++ b/idea/src/org/jetbrains/jet/plugin/presentation/JetLightClassListCellRenderer.java @@ -19,21 +19,21 @@ package org.jetbrains.jet.plugin.presentation; import com.intellij.ide.util.PsiElementListCellRenderer; import com.intellij.psi.presentation.java.ClassPresentationUtil; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; -public class JetLightClassListCellRenderer extends PsiElementListCellRenderer { +public class JetLightClassListCellRenderer extends PsiElementListCellRenderer { @Override - public String getElementText(JetLightClass element) { + public String getElementText(KotlinLightClass element) { return ClassPresentationUtil.getNameForClass(element, false); } @Override - protected String getContainerText(JetLightClass element, final String name) { + protected String getContainerText(KotlinLightClass element, final String name) { return getContainerTextStatic(element); } @Nullable - public static String getContainerTextStatic(final JetLightClass element) { + public static String getContainerTextStatic(final KotlinLightClass element) { return "(" + element.getFqName().parent() + ")"; } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java index 9afe6645e71..9bf5648b758 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java @@ -39,16 +39,13 @@ import com.intellij.psi.search.PsiShortNamesCache; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.Visibilities; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; -import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; @@ -229,20 +226,6 @@ public class ImportClassAndFunFix extends JetHintAction } private static boolean isAccessible(PsiMember member) { - if (member instanceof JetLightClass) { - // TODO: Now light classes losing accessibility information - JetLightClass lightClass = (JetLightClass) member; - BindingContext context = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) lightClass.getContainingFile()).getBindingContext(); - ClassDescriptor descriptor = context.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, lightClass.getFqName()); - - if (descriptor != null) { - return descriptor.getVisibility() == Visibilities.PUBLIC || descriptor.getVisibility() == Visibilities.INTERNAL; - } - else { - assert false : "Descriptor of the class isn't found in the binding context: " + member; - } - } - return member.hasModifierProperty(PsiModifier.PUBLIC) || member.hasModifierProperty(PsiModifier.PROTECTED); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.java b/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.java index 2d072fe5587..3943fcb6c81 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.java @@ -20,22 +20,16 @@ import com.intellij.openapi.editor.Editor; import com.intellij.psi.PsiCompiledElement; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiReference; -import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.refactoring.rename.RenamePsiElementProcessor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.lang.psi.JetFunction; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - public class RenameKotlinFunctionProcessor extends RenamePsiElementProcessor { @Override public boolean canProcessElement(@NotNull PsiElement element) { - if (element instanceof PsiMethod && ((PsiMethod) element).getContainingClass() instanceof JetLightClass) { + if (element instanceof PsiMethod && ((PsiMethod) element).getContainingClass() instanceof KotlinLightClass) { return true; } return element instanceof JetFunction; @@ -44,7 +38,7 @@ public class RenameKotlinFunctionProcessor extends RenamePsiElementProcessor { @Override public PsiElement substituteElementToRename(PsiElement element, @Nullable Editor editor) { if (element instanceof PsiMethod && element instanceof PsiCompiledElement && - ((PsiMethod) element).getContainingClass() instanceof JetLightClass) { + ((PsiMethod) element).getContainingClass() instanceof KotlinLightClass) { return ((PsiCompiledElement) element).getMirror(); } return super.substituteElementToRename(element, editor); diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetJUnitConfigurationProducer.java b/idea/src/org/jetbrains/jet/plugin/run/JetJUnitConfigurationProducer.java index 2b1189ec569..fa94d2c0c01 100644 --- a/idea/src/org/jetbrains/jet/plugin/run/JetJUnitConfigurationProducer.java +++ b/idea/src/org/jetbrains/jet/plugin/run/JetJUnitConfigurationProducer.java @@ -31,7 +31,8 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.*; public class JetJUnitConfigurationProducer extends RuntimeConfigurationProducer { @@ -64,7 +65,7 @@ public class JetJUnitConfigurationProducer extends RuntimeConfigurationProducer JetElement owner = PsiTreeUtil.getParentOfType(function, JetFunction.class, JetClass.class); if (owner instanceof JetClass) { - JetLightClass delegate = JetLightClass.wrapDelegate((JetClass) owner); + KotlinLightClass delegate = LightClassUtil.createLightClass((JetClass) owner); if (delegate != null) { for (PsiMethod method : delegate.getMethods()) { if (method.getNavigationElement() == function) { @@ -95,7 +96,7 @@ public class JetJUnitConfigurationProducer extends RuntimeConfigurationProducer if (jetClass != null) { myElement = jetClass; - PsiClass delegate = JetLightClass.wrapDelegate(jetClass); + PsiClass delegate = LightClassUtil.createLightClass(jetClass); if (delegate != null && JUnitUtil.isTestClass(delegate)) { RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(context.getProject(), context); diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java index 9e7742bf05f..f47563b880a 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java @@ -34,7 +34,8 @@ import com.intellij.util.Processor; import com.intellij.util.indexing.FileBasedIndex; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -81,11 +82,11 @@ public class KotlinAnnotatedElementsSearcher extends AnnotatedElementsSearcher { if (!(DescriptorUtils.getFQName(descriptor).getFqName().equals(annotationFQN))) return; if (parentOfType instanceof JetClass) { - JetLightClass lightClass = JetLightClass.wrapDelegate((JetClass) parentOfType); + KotlinLightClass lightClass = LightClassUtil.createLightClass((JetClass) parentOfType); consumer.process(lightClass); } else if (parentOfType instanceof JetNamedFunction) { - PsiMethod wrappedMethod = JetLightClass.wrapMethod((JetNamedFunction) parentOfType); + PsiMethod wrappedMethod = LightClassUtil.getLightClassMethod((JetNamedFunction) parentOfType); consumer.process(wrappedMethod); } } diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index 728d5f5f1ca..80b17b54aab 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -25,17 +25,17 @@ import com.intellij.psi.search.searches.ClassInheritorsSearch; import com.intellij.util.Processor; import com.intellij.util.Query; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.JetClass; public class KotlinDefinitionsSearcher extends QueryExecutorBase { @Override public void processQuery(@NotNull final PsiElement queryParameters, @NotNull final Processor consumer) { if (queryParameters instanceof JetClass) { - JetLightClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable() { + PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable() { @Override - public JetLightClass compute() { - return JetLightClass.wrapDelegate((JetClass) queryParameters); + public PsiClass compute() { + return LightClassUtil.createLightClass((JetClass) queryParameters); } }); if (psiClass != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java index 8d79d594952..97f632b72bf 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java @@ -23,7 +23,7 @@ import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.DirectClassInheritorsSearch; import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.psi.JetClass; @@ -70,7 +70,7 @@ public class KotlinDirectInheritorsSearcher extends QueryExecutorBase() { + PsiClass lightClass = ApplicationManager.getApplication().runReadAction(new Computable() { @Override - public JetLightClass compute() { - return JetLightClass.wrapDelegate((JetClass) element); + public PsiClass compute() { + return LightClassUtil.createLightClass((JetClass) element); } }); if (lightClass != null) { - queryParameters.getOptimizer().searchWord(className, queryParameters.getScope(), true, lightClass); + queryParameters.getOptimizer().searchWord(className, queryParameters.getEffectiveSearchScope(), true, lightClass); } } } @@ -54,11 +55,11 @@ public class KotlinReferencesSearcher extends QueryExecutorBase() { @Override public PsiMethod compute() { - return JetLightClass.wrapMethod(function); + return LightClassUtil.getLightClassMethod(function); } }); if (method != null) { - queryParameters.getOptimizer().searchWord(name, queryParameters.getScope(), true, method); + queryParameters.getOptimizer().searchWord(name, queryParameters.getEffectiveSearchScope(), true, method); } } } diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index abf35501c87..6cc0784e4a9 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -22,11 +22,10 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; +import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.PluginTestCaseBase; @@ -98,7 +97,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { assertInstanceOf(element, JetNamedFunction.class); JetNamedFunction toString = (JetNamedFunction) element; - assertNull("There should be no wrapper for built-in function", JetLightClass.wrapMethod(toString)); + assertNull("There should be no wrapper for built-in function", LightClassUtil.getLightClassMethod(toString)); } public void testInnerClass() throws Exception { @@ -150,13 +149,8 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { assertInstanceOf(element, JetClass.class); JetClass aClass = (JetClass) element; - JetLightClass createdByWrapDelegate = JetLightClass.wrapDelegate(aClass); + KotlinLightClass createdByWrapDelegate = LightClassUtil.createLightClass(aClass); assertNull(createdByWrapDelegate); - - JetLightClass createdByFactory = JetLightClass.create(element.getManager(), - (JetFile) element.getContainingFile(), - JetPsiUtil.getFQName(aClass)); - assertNull(createdByFactory); } private void doTestWrapMethod(boolean shouldBeWrapped) { @@ -171,7 +165,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { assertNotNull("Caret should be placed to function definition", jetFunction); // Should not fail! - PsiMethod psiMethod = JetLightClass.wrapMethod(jetFunction); + PsiMethod psiMethod = LightClassUtil.getLightClassMethod(jetFunction); if (shouldBeWrapped) { assertNotNull(String.format("Failed to wrap jetFunction '%s' to method", jetFunction.getText()), psiMethod); @@ -195,7 +189,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { assertNotNull("Caret should be placed to class definition", jetClass); // Should not fail! - JetLightClass lightClass = JetLightClass.wrapDelegate(jetClass); + KotlinLightClass lightClass = LightClassUtil.createLightClass(jetClass); assertNotNull(String.format("Failed to wrap jetClass '%s' to class", jetClass.getText()), lightClass); diff --git a/idea/tests/org/jetbrains/jet/testing/ReferenceUtils.java b/idea/tests/org/jetbrains/jet/testing/ReferenceUtils.java index de5f9fcfea1..081de3ca4b1 100644 --- a/idea/tests/org/jetbrains/jet/testing/ReferenceUtils.java +++ b/idea/tests/org/jetbrains/jet/testing/ReferenceUtils.java @@ -21,7 +21,7 @@ import com.intellij.navigation.NavigationItem; import com.intellij.psi.PsiElement; import junit.framework.Assert; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.JetLightClass; +import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.plugin.presentation.JetLightClassListCellRenderer; public final class ReferenceUtils { @@ -29,8 +29,8 @@ public final class ReferenceUtils { } public static String renderAsGotoImplementation(@NotNull PsiElement element) { - if (element instanceof JetLightClass) { - JetLightClass jetLightClass = (JetLightClass) element; + if (element instanceof KotlinLightClass) { + KotlinLightClass jetLightClass = (KotlinLightClass) element; JetLightClassListCellRenderer renderer = new JetLightClassListCellRenderer(); String elementText = renderer.getElementText(jetLightClass); String containerText = JetLightClassListCellRenderer.getContainerTextStatic(jetLightClass);