StackOverlowes fixed with FQNames remembered in trace

compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java

 package org.jetbrains.jet.codegen;
 
 import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
 
 import java.util.*;
 
@@ -31,7 +32,7 @@ public class ClassFileFactory {
 
     NamespaceCodegen forNamespace(JetNamespace namespace) {
         assert !isDone : "Already done!";
-        String fqName = CodegenUtil.getFQName(namespace);
+        String fqName = JetPsiUtil.getFQName(namespace);
         NamespaceCodegen codegen = ns2codegen.get(fqName);
         if (codegen == null) {
             final ClassBuilder builder = newVisitor(NamespaceCodegen.getJVMClassName(fqName) + ".class");

compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java

 package org.jetbrains.jet.codegen;
 
-import com.intellij.psi.util.PsiTreeUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.ExpressionAsFunctionDescriptor;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
@@ -108,40 +105,6 @@ public class CodegenUtil {
         return hasTypeInfoField(outerClassDescriptor.getDefaultType());
     }
 
-    public static String getFQName(JetNamespace jetNamespace) {
-        JetNamespace parent = PsiTreeUtil.getParentOfType(jetNamespace, JetNamespace.class);
-        if (parent != null) {
-            String parentFQName = getFQName(parent);
-            if (parentFQName.length() > 0) {
-                return parentFQName + "." + getFQName(jetNamespace.getHeader());
-            }
-        }
-        return getFQName(jetNamespace.getHeader()); // TODO: Must include module root namespace
-    }
-
-    private static String getFQName(JetNamespaceHeader header) {
-        StringBuilder builder = new StringBuilder();
-        for (Iterator<JetSimpleNameExpression> iterator = header.getParentNamespaceNames().iterator(); iterator.hasNext(); ) {
-            JetSimpleNameExpression nameExpression = iterator.next();
-            builder.append(nameExpression.getReferencedName());
-            builder.append(".");
-        }
-//        PsiElement nameIdentifier = header.getNameIdentifier();
-        builder.append(header.getName());
-        return builder.toString();
-    }
-
-    public static String getFQName(JetClass jetClass) {
-        JetNamedDeclaration parent = PsiTreeUtil.getParentOfType(jetClass, JetNamespace.class, JetClass.class);
-        if (parent instanceof JetNamespace) {
-            return getFQName(((JetNamespace) parent)) + "." + jetClass.getName();
-        }
-        if (parent instanceof JetClass) {
-            return getFQName(((JetClass) parent)) + "." + jetClass.getName();
-        }
-        return jetClass.getName();
-    }
-
     public static FunctionDescriptor createInvoke(ExpressionAsFunctionDescriptor fd) {
         int arity = fd.getValueParameters().size();
         FunctionDescriptorImpl invokeDescriptor = new FunctionDescriptorImpl(

compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java

@@ -629,7 +629,7 @@ public class JetTypeMapper {
 
         String baseName;
         if (container instanceof JetNamespace) {
-            baseName = NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(((JetNamespace) container)));
+            baseName = NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(((JetNamespace) container)));
         }
         else {
             ClassDescriptor aClass = bindingContext.get(BindingContext.CLASS, container);

compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java

@@ -5,9 +5,6 @@ import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.CharsetToolkit;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiFile;
 import com.intellij.util.Function;
 import com.intellij.util.Processor;
 import jet.modules.IModuleBuilder;
@@ -15,16 +12,15 @@ import jet.modules.IModuleSetBuilder;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.CodegenUtil;
 import org.jetbrains.jet.codegen.GeneratedClassLoader;
 import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.plugin.JetMainDetector;
 
 import java.io.*;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.jar.*;
@@ -332,7 +328,7 @@ public class CompileEnvironment {
         String mainClass = null;
         for (JetNamespace namespace : session.getSourceFileNamespaces()) {
             if (JetMainDetector.hasMain(namespace.getDeclarations())) {
-                mainClass = CodegenUtil.getFQName(namespace) + ".namespace";
+                mainClass = JetPsiUtil.getFQName(namespace) + ".namespace";
                 break;
             }
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -76,6 +76,12 @@ public class JavaDescriptorResolver {
     @NotNull
     public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) {
         String qualifiedName = psiClass.getQualifiedName();
+
+        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
+        if (kotlinClassDescriptor != null) {
+            return kotlinClassDescriptor;
+        }
+
         ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName);
         if (classDescriptor == null) {
             classDescriptor = createJavaClassDescriptor(psiClass);
@@ -86,6 +92,11 @@ public class JavaDescriptorResolver {
 
     @Nullable
     public ClassDescriptor resolveClass(@NotNull String qualifiedName) {
+        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
+        if (kotlinClassDescriptor != null) {
+            return kotlinClassDescriptor;
+        }
+
         ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName);
         if (classDescriptor == null) {
             PsiClass psiClass = findClass(qualifiedName);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java

@@ -5,10 +5,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
 import java.util.Collection;
@@ -44,6 +41,11 @@ public class JavaPackageScope extends JetScopeImpl {
     @NotNull
     @Override
     public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
+        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
+        if (kotlinNamespaceDescriptor != null) {
+            return Collections.emptySet();
+        }
+
         // TODO: what is GlobalSearchScope
         PsiClass psiClass = semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName("namespace"));
         if (psiClass == null) {
@@ -54,7 +56,9 @@ public class JavaPackageScope extends JetScopeImpl {
             return Collections.emptySet();
         }
 
+        System.out.println(psiClass.getQualifiedName());
         return semanticServices.getDescriptorResolver().resolveFunctionGroup(containingDescriptor, psiClass, null, name, true);
+//            return Collections.emptySet();
     }
 
     @NotNull
@@ -79,6 +83,11 @@ public class JavaPackageScope extends JetScopeImpl {
                 }
 
                 for (PsiClass psiClass : javaPackage.getClasses()) {
+                    ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(psiClass.getQualifiedName());
+                    if (kotlinClassDescriptor != null) {
+                        continue;
+                    }
+
                     if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
                         allDescriptors.add(descriptorResolver.resolveClass(psiClass));
                     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java

@@ -2,7 +2,11 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 
 /**
@@ -39,4 +43,14 @@ public class JavaSemanticServices {
     public JetSemanticServices getJetSemanticServices() {
         return jetSemanticServices;
     }
+    
+    @Nullable
+    public ClassDescriptor getKotlinClassDescriptor(String qualifiedName) {
+        return getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
+    }
+
+    @Nullable
+    public NamespaceDescriptor getKotlinNamespaceDescriptor(String qualifiedName) {
+        return getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, qualifiedName);
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java

@@ -8,6 +8,7 @@ import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Set;
 
 /**
@@ -103,4 +104,38 @@ public class JetPsiUtil {
             return unquoteIdentifier(quoted);
         }
     }
+
+    public static String getFQName(JetNamespace jetNamespace) {
+        JetNamespace parent = PsiTreeUtil.getParentOfType(jetNamespace, JetNamespace.class);
+        if (parent != null) {
+            String parentFQName = getFQName(parent);
+            if (parentFQName.length() > 0) {
+                return parentFQName + "." + getFQName(jetNamespace.getHeader());
+            }
+        }
+        return getFQName(jetNamespace.getHeader()); // TODO: Must include module root namespace
+    }
+
+    private static String getFQName(JetNamespaceHeader header) {
+        StringBuilder builder = new StringBuilder();
+        for (Iterator<JetSimpleNameExpression> iterator = header.getParentNamespaceNames().iterator(); iterator.hasNext(); ) {
+            JetSimpleNameExpression nameExpression = iterator.next();
+            builder.append(nameExpression.getReferencedName());
+            builder.append(".");
+        }
+//        PsiElement nameIdentifier = header.getNameIdentifier();
+        builder.append(header.getName());
+        return builder.toString();
+    }
+
+    public static String getFQName(JetClass jetClass) {
+        JetNamedDeclaration parent = PsiTreeUtil.getParentOfType(jetClass, JetNamespace.class, JetClass.class);
+        if (parent instanceof JetNamespace) {
+            return getFQName(((JetNamespace) parent)) + "." + jetClass.getName();
+        }
+        if (parent instanceof JetClass) {
+            return getFQName(((JetClass) parent)) + "." + jetClass.getName();
+        }
+        return jetClass.getName();
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java

@@ -18,6 +18,8 @@ import org.jetbrains.jet.util.slicedmap.*;
 
 import java.util.Collection;
 
+import static org.jetbrains.jet.util.slicedmap.RewritePolicy.DO_NOTHING;
+
 /**
  * @author abreslav
  */
@@ -26,12 +28,12 @@ public interface BindingContext {
 
     WritableSlice<JetExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice();
     WritableSlice<JetTypeReference, JetType> TYPE = Slices.createSimpleSlice();
-    WritableSlice<JetExpression, JetType> EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(RewritePolicy.DO_NOTHING);
+    WritableSlice<JetExpression, JetType> EXPRESSION_TYPE = new BasicWritableSlice<JetExpression, JetType>(DO_NOTHING);
 
-    WritableSlice<JetReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, DeclarationDescriptor>(RewritePolicy.DO_NOTHING);
-    WritableSlice<JetElement, ResolvedCall<? extends CallableDescriptor>> RESOLVED_CALL = new BasicWritableSlice<JetElement, ResolvedCall<? extends CallableDescriptor>>(RewritePolicy.DO_NOTHING);
+    WritableSlice<JetReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
+    WritableSlice<JetElement, ResolvedCall<? extends CallableDescriptor>> RESOLVED_CALL = new BasicWritableSlice<JetElement, ResolvedCall<? extends CallableDescriptor>>(DO_NOTHING);
 
-    WritableSlice<JetReferenceExpression, Collection<? extends ResolvedCallImpl<? extends DeclarationDescriptor>>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, Collection<? extends ResolvedCallImpl<? extends DeclarationDescriptor>>>(RewritePolicy.DO_NOTHING);
+    WritableSlice<JetReferenceExpression, Collection<? extends ResolvedCallImpl<? extends DeclarationDescriptor>>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice<JetReferenceExpression, Collection<? extends ResolvedCallImpl<? extends DeclarationDescriptor>>>(DO_NOTHING);
 
     WritableSlice<JetExpression, FunctionDescriptor> LOOP_RANGE_ITERATOR = Slices.createSimpleSlice();
     WritableSlice<JetExpression, CallableDescriptor> LOOP_RANGE_HAS_NEXT = Slices.createSimpleSlice();
@@ -61,7 +63,7 @@ public interface BindingContext {
 
     WritableSlice<Box<DeferredType>, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice();
 
-    WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new Slices.SetSlice<PropertyDescriptor>(RewritePolicy.DO_NOTHING) {
+    WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new Slices.SetSlice<PropertyDescriptor>(DO_NOTHING) {
         @Override
         public Boolean computeValue(SlicedMap map, PropertyDescriptor propertyDescriptor, Boolean backingFieldRequired, boolean valueNotFound) {
             backingFieldRequired = valueNotFound ? false : backingFieldRequired;
@@ -92,7 +94,7 @@ public interface BindingContext {
     };
     WritableSlice<PropertyDescriptor, Boolean> IS_INITIALIZED = Slices.createSimpleSetSlice();
 
-    WritableSlice<JetFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<JetFunctionLiteralExpression>(RewritePolicy.DO_NOTHING) {
+    WritableSlice<JetFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<JetFunctionLiteralExpression>(DO_NOTHING) {
         @Override
         public Boolean computeValue(SlicedMap map, JetFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
             isBlock = valueNotFound ? false : isBlock;
@@ -136,6 +138,9 @@ public interface BindingContext {
     WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.<JetReferenceExpression, PsiElement>sliceBuilder().build();
     WritableSlice<JetParameter, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.<JetParameter, PropertyDescriptor>sliceBuilder().build();
 
+    WritableSlice<String, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<String, ClassDescriptor>(DO_NOTHING);
+    WritableSlice<String, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice<String, NamespaceDescriptor>(DO_NOTHING);
+
     @SuppressWarnings("UnusedDeclaration")
     @Deprecated // This field is needed only for the side effects of its initializer
     Void _static_initializer = BasicWritableSlice.initSliceDebugNames(BindingContext.class);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -20,7 +20,6 @@ import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.*;
@@ -91,6 +90,7 @@ public class TypeHierarchyResolver {
                 @Override
                 public void visitClass(JetClass klass) {
                     MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(context.getTrace(), owner, outerScope, getClassKind(klass));
+                    context.getTrace().record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(klass), mutableClassDescriptor);
 
                     if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) {
                         MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(context.getTrace(), mutableClassDescriptor, outerScope, ClassKind.OBJECT);
@@ -217,6 +217,7 @@ public class TypeHierarchyResolver {
                     Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
                     name
             );
+            context.getTrace().record(FQNAME_TO_NAMESPACE_DESCRIPTOR, DescriptorUtils.getFQName(namespaceDescriptor), namespaceDescriptor);
             WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope");
             scope.changeLockLevel(WritableScope.LockLevel.BOTH);
             namespaceDescriptor.initialize(scope);

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

 package org.jetbrains.jet.codegen;
 
-import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.CharsetToolkit;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.parsing.JetParsingTest;
-import org.junit.Assert;
 
-import java.io.File;
-import java.io.FilenameFilter;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -99,7 +92,7 @@ public abstract class CodegenTestCase extends JetLiteFixture {
         GeneratedClassLoader loader = new GeneratedClassLoader(codegens);
 
         final JetNamespace namespace = myFile.getRootNamespace();
-        String fqName = NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(namespace)).replace("/", ".");
+        String fqName = NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(namespace)).replace("/", ".");
         Class<?> namespaceClass = loader.loadClass(fqName);
         Method method = namespaceClass.getMethod("box");
         return (String) method.invoke(null);
@@ -120,7 +113,7 @@ public abstract class CodegenTestCase extends JetLiteFixture {
 
     protected Class loadRootNamespaceClass(ClassFileFactory state) {
         final JetNamespace namespace = myFile.getRootNamespace();
-        String fqName = NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(namespace)).replace("/", ".");
+        String fqName = NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(namespace)).replace("/", ".");
         Map<String, Class> classMap = loadAllClasses(state);
         return classMap.get(fqName);
     }

idea/src/META-INF/plugin.xml

@@ -59,9 +59,7 @@
       <codeInsight.overrideMethod language="jet" implementationClass="org.jetbrains.jet.plugin.codeInsight.OverrideMethodsHandler"/>
 
 
-      <!--
       <java.elementFinder implementation="org.jetbrains.jet.plugin.java.JavaElementFinder"/>
-      -->
       <toolWindow id="CodeWindow"
                   factoryClass="org.jetbrains.jet.plugin.internal.codewindow.BytecodeToolwindow$Factory"
                   anchor="right"/>

idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java

@@ -17,7 +17,6 @@ import com.sun.jdi.ReferenceType;
 import com.sun.jdi.request.ClassPrepareRequest;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.codegen.CodegenUtil;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.NamespaceCodegen;
@@ -113,10 +112,10 @@ public class JetPositionManager implements PositionManager {
         else {
             JetNamespace namespace = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetNamespace.class);
             if (namespace != null) {
-                names.add(NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(namespace)));
+                names.add(NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(namespace)));
             }
             else {
-                names.add(NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(file.getRootNamespace())));
+                names.add(NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(file.getRootNamespace())));
             }
         }
         return names;

idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java

@@ -15,11 +15,7 @@ import com.intellij.psi.impl.file.PsiPackageImpl;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.util.SmartList;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.codegen.CodegenUtil;
-import org.jetbrains.jet.lang.psi.JetClassOrObject;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
-import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.util.ArrayList;
@@ -52,7 +48,7 @@ public class JavaElementFinder extends PsiElementFinder {
         final List<JetFile> filesInScope = collectProjectFiles(project, scope);
         for (JetFile file : filesInScope) {
             JetNamespace rootNamespace = file.getRootNamespace();
-            final String packageName = CodegenUtil.getFQName(rootNamespace);
+            final String packageName = JetPsiUtil.getFQName(rootNamespace);
             if (packageName != null && qualifiedName.startsWith(packageName)) {
                 if (qualifiedName.equals(fqn(packageName, "namespace"))) {
                     answer.add(new JetLightClass(psiManager, file, "namespace"));
@@ -77,7 +73,7 @@ public class JavaElementFinder extends PsiElementFinder {
         String packageFQN = psiPackage.getQualifiedName();
         for (JetFile psiFile : collectProjectFiles(project, GlobalSearchScope.allScope(project))) {
             final JetNamespace rootNamespace = psiFile.getRootNamespace();
-            if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
+            if (packageFQN.equals(JetPsiUtil.getFQName(rootNamespace))) {
                 answer.add("namespace");
                 for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
                     if (declaration instanceof JetClassOrObject) {
@@ -100,7 +96,7 @@ public class JavaElementFinder extends PsiElementFinder {
         final List<JetFile> psiFiles = collectProjectFiles(project, GlobalSearchScope.allScope(project));
 
         for (JetFile psiFile : psiFiles) {
-            if (qualifiedName.equals(CodegenUtil.getFQName(psiFile.getRootNamespace()))) {
+            if (qualifiedName.equals(JetPsiUtil.getFQName(psiFile.getRootNamespace()))) {
                 return new PsiPackageImpl(psiFile.getManager(), qualifiedName);
             }
         }
@@ -116,7 +112,7 @@ public class JavaElementFinder extends PsiElementFinder {
         String packageFQN = psiPackage.getQualifiedName();
         for (JetFile file : filesInScope) {
             final JetNamespace rootNamespace = file.getRootNamespace();
-            if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
+            if (packageFQN.equals(JetPsiUtil.getFQName(rootNamespace))) {
                 answer.add(new JetLightClass(psiManager, file, "namespace"));
                 for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
                     if (declaration instanceof JetClassOrObject) {

idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java

@@ -19,10 +19,10 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.ClassBuilder;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
-import org.jetbrains.jet.codegen.CodegenUtil;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
 import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
@@ -75,8 +75,13 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
 
         return null;
     }
-    
-    
+
+    @Override
+    public String getQualifiedName() {
+        String fqName = JetPsiUtil.getFQName(file.getRootNamespace());
+        return fqName.length() == 0 ? className : fqName + "." + className;
+    }
+
     private PsiJavaFileStub getStub() {
         PsiJavaFileStub answer = file.getUserData(JAVA_API_STUB);
         if (answer == null) {
@@ -88,7 +93,7 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
     }
     
     private PsiJavaFileStub calcStub() {
-        final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(CodegenUtil.getFQName(file.getRootNamespace()), true);
+        final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(JetPsiUtil.getFQName(file.getRootNamespace()), true);
         final Project project = getProject();
         
         final Stack<StubElement> stubStack = new Stack<StubElement>();
@@ -148,5 +153,5 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
 
         return answer;
     }
-    
+
 }

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java

@@ -8,10 +8,10 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
-import org.jetbrains.jet.codegen.CodegenUtil;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.plugin.JetMainDetector;
 
 /**
@@ -34,14 +34,14 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
         JetClass containingClass = (JetClass) location.getParentElement(JetClass.class);
         if (containingClass != null && JetMainDetector.hasMain(containingClass.getDeclarations())) {
             mySourceElement = containingClass;
-            return createConfigurationByQName(location.getModule(), configurationContext, CodegenUtil.getFQName(containingClass));
+            return createConfigurationByQName(location.getModule(), configurationContext, JetPsiUtil.getFQName(containingClass));
         }
         PsiFile psiFile = location.getPsiElement().getContainingFile();
         if (psiFile instanceof JetFile) {
             JetNamespace namespace = ((JetFile) psiFile).getRootNamespace();
             if (JetMainDetector.hasMain(namespace.getDeclarations())) {
                 mySourceElement = namespace;
-                String fqName = CodegenUtil.getFQName(namespace);
+                String fqName = JetPsiUtil.getFQName(namespace);
                 String className = fqName.length() == 0 ? "namespace" : fqName + ".namespace";
                 return createConfigurationByQName(location.getModule(), configurationContext, className);
             }