Java resolve fixed

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

@@ -3,14 +3,12 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -22,7 +20,7 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
 
     private TypeConstructor typeConstructor;
     private JavaClassMembersScope unsubstitutedMemberScope;
-    private JetType classObjectType;
+//    private JetType classObjectType;
     private final Set<FunctionDescriptor> constructors = Sets.newLinkedHashSet();
     private Modality modality;
     private Visibility visibility;
@@ -52,19 +50,19 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
         this.unsubstitutedMemberScope = memberScope;
     }
 
-    public void setClassObjectMemberScope(JavaClassMembersScope memberScope) {
-        classObjectType = new JetTypeImpl(
-                new TypeConstructorImpl(
-                        JavaDescriptorResolver.JAVA_CLASS_OBJECT,
-                        Collections.<AnnotationDescriptor>emptyList(),
-                        true,
-                        "Class object emulation for " + getName(),
-                        Collections.<TypeParameterDescriptor>emptyList(),
-                        Collections.<JetType>emptyList()
-                ),
-                memberScope
-        );
-    }
+//    public void setClassObjectMemberScope(JavaClassMembersScope memberScope) {
+//        classObjectType = new JetTypeImpl(
+//                new TypeConstructorImpl(
+//                        JavaDescriptorResolver.JAVA_CLASS_OBJECT,
+//                        Collections.<AnnotationDescriptor>emptyList(),
+//                        true,
+//                        "Class object emulation for " + getName(),
+//                        Collections.<TypeParameterDescriptor>emptyList(),
+//                        Collections.<JetType>emptyList()
+//                ),
+//                memberScope
+//        );
+//    }
 
     public void addConstructor(ConstructorDescriptor constructorDescriptor) {
         this.constructors.add(constructorDescriptor);
@@ -133,7 +131,7 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
 
     @Override
     public JetType getClassObjectType() {
-        return classObjectType;
+        return null;
     }
 
     @Override

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

@@ -161,11 +161,11 @@ public class JavaClassMembersScope implements JetScope {
     @NotNull
     @Override
     public ReceiverDescriptor getImplicitReceiver() {
-        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
+        return ReceiverDescriptor.NO_RECEIVER; // Should never occur, we don't sit in a Java class...
     }
 
     @Override
     public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
-        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
+        // we cannot really be scoped inside here
     }
 }

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

@@ -53,7 +53,7 @@ public class JavaDescriptorResolver {
     protected final Map<PsiTypeParameter, TypeParameterDescriptor> typeParameterDescriptorCache = Maps.newHashMap();
     protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
     protected final Map<PsiField, VariableDescriptor> fieldDescriptorCache = Maps.newHashMap();
-    protected final Map<PsiPackage, NamespaceDescriptor> namespaceDescriptorCache = Maps.newHashMap();
+    protected final Map<PsiElement, NamespaceDescriptor> namespaceDescriptorCache = Maps.newHashMap();
     protected final JavaPsiFacade javaFacade;
     protected final GlobalSearchScope javaSearchScope;
     protected final JavaSemanticServices semanticServices;
@@ -116,7 +116,7 @@ public class JavaDescriptorResolver {
         classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), psiClass));
         classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor);
         classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false));
-        classDescriptor.setClassObjectMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, true));
+//        classDescriptor.setClassObjectMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, true));
         // UGLY HACK
         supertypes.addAll(getSupertypes(psiClass));
         if (psiClass.isInterface()) {
@@ -237,7 +237,9 @@ public class JavaDescriptorResolver {
     public NamespaceDescriptor resolveNamespace(String qualifiedName) {
         PsiPackage psiPackage = javaFacade.findPackage(qualifiedName);
         if (psiPackage == null) {
-            return null;
+            PsiClass psiClass = javaFacade.findClass(qualifiedName, javaSearchScope);
+            if (psiClass == null) return null;
+            return resolveNamespace(psiClass);
         }
         return resolveNamespace(psiPackage);
     }
@@ -245,20 +247,21 @@ public class JavaDescriptorResolver {
     private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) {
         NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiPackage);
         if (namespaceDescriptor == null) {
-            // TODO : packages
-
-//            PsiClass psiClass = javaFacade.findClass(qualifiedName, javaSearchScope);
-//            if (psiClass != null) {
-//                namespaceDescriptor = createJavaNamespaceDescriptor(psiClass);
-//            }
-//            else {
-                namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage);
-//            }
+            namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage);
             namespaceDescriptorCache.put(psiPackage, namespaceDescriptor);
         }
         return namespaceDescriptor;
     }
 
+    private NamespaceDescriptor resolveNamespace(@NotNull PsiClass psiClass) {
+        NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiClass);
+        if (namespaceDescriptor == null) {
+            namespaceDescriptor = createJavaNamespaceDescriptor(psiClass);
+            namespaceDescriptorCache.put(psiClass, namespaceDescriptor);
+        }
+        return namespaceDescriptor;
+    }
+
     private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) {
         String name = psiPackage.getName();
         JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor(

compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver;
-import org.jetbrains.jet.lexer.JetToken;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
@@ -869,25 +868,24 @@ public class JetTypeInferrer {
             if (classifier != null) {
                 JetType classObjectType = classifier.getClassObjectType();
                 JetType result = null;
-                if (classObjectType != null && (isNamespacePosition() || classifier.isClassObjectAValue())) {
-                    result = classObjectType;
-                }
-                else {
-//                    context.trace.getErrorHandler().genericError(expression.getNode(), "Classifier " + classifier.getName() +  " does not have a class object");
-                    context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
-                }
-                context.trace.record(REFERENCE_TARGET, expression, classifier);
-                if (result == null) {
-                    return ErrorUtils.createErrorType("No class object in " + expression.getReferencedName());
+                if (classObjectType != null) {
+                    if (isNamespacePosition() || classifier.isClassObjectAValue()) {
+                        result = classObjectType;
+                    }
+                    else {
+    //                    context.trace.getErrorHandler().genericError(expression.getNode(), "Classifier " + classifier.getName() +  " does not have a class object");
+                        context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
+                    }
+                    context.trace.record(REFERENCE_TARGET, expression, classifier);
+                    if (result == null) {
+                        return ErrorUtils.createErrorType("No class object in " + expression.getReferencedName());
+                    }
+                    return context.services.checkType(result, expression, context);
                 }
-                return context.services.checkType(result, expression, context);
             }
-            else {
-                JetType[] result = new JetType[1];
-                if (furtherNameLookup(expression, referencedName, result, context)) {
-                    return context.services.checkType(result[0], expression, context);
-                }
-
+            JetType[] result = new JetType[1];
+            if (furtherNameLookup(expression, referencedName, result, context)) {
+                return context.services.checkType(result[0], expression, context);
             }
             return null;
         }