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

JetLightClass removed (replaced by KotlinLightClass implementations)

Browse Source
This commit is contained in:
Andrey Breslav
2012-12-28 19:01:54 +04:00
parent d9ed18dc00
commit 40943fa6d2
17 changed files with 118 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java
-312
View File
@@ -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<CachedValue<PsiJavaFileStub>> 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<PsiJavaFileStub> answer = file.getUserData(JAVA_API_STUB);
if (answer == null) {
answer = CachedValuesManager.getManager(getProject()).createCachedValue(new CachedValueProvider<PsiJavaFileStub>() {
@Override
public Result<PsiJavaFileStub> 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<StubElement> stubStack = new Stack<StubElement>();
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;
}
}
compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClass.java
+3
View File
@@ -23,4 +23,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
public interface KotlinLightClass extends PsiClass {
@NotNull
FqName getFqName();
@NotNull
PsiClass getDelegate();
}
compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java
+68 -3
View File
@@ -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() {}
}
idea/src/org/jetbrains/jet/plugin/JetGotoTargetRenderProvider.java
+2 -2
View File
@@ -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();
}
idea/src/org/jetbrains/jet/plugin/JetIconProvider.java
-5
View File
@@ -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;
}
}
idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java
+2 -2
View File
@@ -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;
}
idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java
+4 -3
View File
@@ -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;
}
idea/src/org/jetbrains/jet/plugin/presentation/JetLightClassListCellRenderer.java
+5 -5
View File
@@ -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<JetLightClass> {
public class JetLightClassListCellRenderer extends PsiElementListCellRenderer<KotlinLightClass> {
@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() + ")";
}
idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java
-17
View File
@@ -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<JetSimpleNameExpression>
}
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);
}
idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.java
+3 -9
View File
@@ -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);
idea/src/org/jetbrains/jet/plugin/run/JetJUnitConfigurationProducer.java
+4 -3
View File
@@ -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);
idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java
+4 -3
View File
@@ -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);
}
}
idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java
+4 -4
View File
@@ -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<PsiElement, PsiElement> {
@Override
public void processQuery(@NotNull final PsiElement queryParameters, @NotNull final Processor<PsiElement> consumer) {
if (queryParameters instanceof JetClass) {
JetLightClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<JetLightClass>() {
PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
@Override
public JetLightClass compute() {
return JetLightClass.wrapDelegate((JetClass) queryParameters);
public PsiClass compute() {
return LightClassUtil.createLightClass((JetClass) queryParameters);
}
});
if (psiClass != null) {
idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java
+2 -2
View File
@@ -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,
if (declarationDescriptor != null) {
String fqName = DescriptorUtils.getFQName(declarationDescriptor).getFqName();
if (qualifiedName.equals(fqName)) {
JetLightClass lightClass = JetLightClass.wrapDelegate((JetClass) candidate);
PsiClass lightClass = LightClassUtil.createLightClass(candidate);
if (lightClass != null) {
consumer.process(lightClass);
}
idea/src/org/jetbrains/jet/plugin/search/KotlinReferencesSearcher.java
+8 -7
View File
@@ -19,13 +19,14 @@ package org.jetbrains.jet.plugin.search;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.QueryExecutorBase;
import com.intellij.openapi.util.Computable;
import com.intellij.psi.PsiClass;
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.util.Processor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.asJava.JetLightClass;
import org.jetbrains.jet.asJava.LightClassUtil;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
@@ -36,14 +37,14 @@ public class KotlinReferencesSearcher extends QueryExecutorBase<PsiReference, Re
if (element instanceof JetClass) {
String className = ((JetClass) element).getName();
if (className != null) {
JetLightClass lightClass = ApplicationManager.getApplication().runReadAction(new Computable<JetLightClass>() {
PsiClass lightClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
@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<PsiReference, Re
final PsiMethod method = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod>() {
@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);
}
}
}
idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java
+6 -12
View File
@@ -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);
idea/tests/org/jetbrains/jet/testing/ReferenceUtils.java
+3 -3
View File
@@ -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);