JetLightClass removed (replaced by KotlinLightClass implementations)

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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() {
+                public PsiClass compute() {
-                    return JetLightClass.wrapDelegate((JetClass) queryParameters);
+                    return LightClassUtil.createLightClass((JetClass) queryParameters);
                 }
             });
             if (psiClass != null) {

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,
                         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

@@ -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() {
+                    public PsiClass compute() {
-                        return JetLightClass.wrapDelegate((JetClass) element);
+                        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

@@ -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

@@ -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) {
+        if (element instanceof KotlinLightClass) {
-            JetLightClass jetLightClass = (JetLightClass) element;
+            KotlinLightClass jetLightClass = (KotlinLightClass) element;
             JetLightClassListCellRenderer renderer = new JetLightClassListCellRenderer();
             String elementText = renderer.getElementText(jetLightClass);
             String containerText = JetLightClassListCellRenderer.getContainerTextStatic(jetLightClass);