more descriptorToDeclaration utils

* custom versions
* normalization code moved out of norializer
* hide DESCRIPTOR_TO_DECLARATION (make package local)

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

@@ -1434,8 +1434,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
     public StackValue generateThisOrOuter(ClassDescriptor calleeContainingClass) {
         CodegenContext cur = context;
 
-        PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(bindingContext, calleeContainingClass);
+        PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(bindingContext, calleeContainingClass);
-        boolean isObject = psiElement instanceof JetClassOrObject && CodegenUtil.isNonLiteralObject((JetClassOrObject)psiElement);
+        boolean isObject = psiElement instanceof JetClassOrObject && CodegenUtil.isNonLiteralObject((JetClassOrObject) psiElement);
         
         cur = context;
         StackValue result = StackValue.local(0, TYPE_OBJECT);

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

@@ -440,7 +440,7 @@ public class FunctionCodegen {
 
                 iv.areturn(jvmSignature.getReturnType());
 
-                endVisit(mv, "default method", BindingContextUtils.descriptorToDeclaration(state.getBindingContext(), functionDescriptor));
+                endVisit(mv, "default method", BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
                 mv.visitEnd();
             }
         }
@@ -500,7 +500,7 @@ public class FunctionCodegen {
                 if(jvmSignature.getReturnType() == Type.VOID_TYPE)
                     iv.aconst(null);
                 iv.areturn(overriden.getReturnType());
-                endVisit(mv, "bridge method", BindingContextUtils.descriptorToDeclaration(state.getBindingContext(), functionDescriptor));
+                endVisit(mv, "bridge method", BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
             }
         }
     }

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

@@ -634,7 +634,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 StackValue field = StackValue.field(fieldType, classname, delegateField, false);
                 field.store(iv);
 
-                JetClass superClass = (JetClass) BindingContextUtils.descriptorToDeclaration(bindingContext, superClassDescriptor);
+                JetClass superClass = (JetClass) BindingContextUtils.classDescriptorToDeclaration(bindingContext, superClassDescriptor);
                 final CodegenContext delegateContext = context.intoClass(superClassDescriptor,
                         new OwnerKind.DelegateKind(StackValue.field(fieldType, classname, delegateField, false),
                                 typeMapper.mapType(superClassDescriptor.getDefaultType(), MapTypeMode.IMPL).getInternalName()), state.getInjector().getJetTypeMapper());
@@ -723,7 +723,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         DeclarationDescriptor containingDeclaration = fun.getContainingDeclaration();
         if(containingDeclaration instanceof ClassDescriptor) {
             ClassDescriptor declaration = (ClassDescriptor) containingDeclaration;
-            PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(bindingContext, declaration);
+            PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(bindingContext, declaration);
             if(psiElement instanceof JetClass) {
                 JetClass jetClass = (JetClass) psiElement;
                 if(jetClass.isTrait()) {
@@ -765,7 +765,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                             iv.checkcast(function.getReturnType());
                         }
                         iv.areturn(function.getReturnType());
-                        FunctionCodegen.endVisit(iv, "trait method", BindingContextUtils.descriptorToDeclaration(bindingContext, fun));
+                        FunctionCodegen.endVisit(iv, "trait method", BindingContextUtils.callableDescriptorToDeclaration(bindingContext, fun));
                     }
 
                     FunctionCodegen.generateBridgeIfNeeded(context, state, v, function, fun, kind);

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

@@ -82,7 +82,7 @@ public class ObjectOrClosureCodegen {
             final int idx = exprContext.lookupLocal(vd);
             if (idx < 0) return null;
 
-            JetElement expression = (JetElement) BindingContextUtils.descriptorToDeclaration(state.getBindingContext(), vd);
+            JetElement expression = (JetElement) BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), vd);
             String cn = state.getInjector().getJetTypeMapper().getClosureAnnotator().classNameForAnonymousClass(expression);
             Type localType = Type.getObjectType(cn);
 

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

@@ -35,7 +35,7 @@ public class TraitImplBodyCodegen extends ClassBodyCodegen {
 
     //todo not needed when frontend will be able to calculate properly
     static JetType getSuperClass(ClassDescriptor myClassDescr, BindingContext bindingContext) {
-        JetClassOrObject myClass = (JetClassOrObject) BindingContextUtils.descriptorToDeclaration(bindingContext, myClassDescr);
+        JetClassOrObject myClass = (JetClassOrObject) BindingContextUtils.classDescriptorToDeclaration(bindingContext, myClassDescr);
         if(myClass == null)
             return JetStandardClasses.getAnyType();
         List<JetDelegationSpecifier> delegationSpecifiers = myClass.getDelegationSpecifiers();
@@ -44,7 +44,7 @@ public class TraitImplBodyCodegen extends ClassBodyCodegen {
             if (specifier instanceof JetDelegatorToSuperClass || specifier instanceof JetDelegatorToSuperCall) {
                 JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference());
                 ClassDescriptor superClassDescriptor = (ClassDescriptor) superType.getConstructor().getDeclarationDescriptor();
-                final PsiElement declaration = BindingContextUtils.descriptorToDeclaration(bindingContext, superClassDescriptor);
+                final PsiElement declaration = BindingContextUtils.classDescriptorToDeclaration(bindingContext, superClassDescriptor);
                 if (declaration != null) {
                     if (declaration instanceof PsiClass) {
                         if (!((PsiClass) declaration).isInterface()) {

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

@@ -74,6 +74,7 @@ import org.jetbrains.jet.lang.descriptors.Visibility;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.FqName;
@@ -1575,6 +1576,7 @@ public class JavaDescriptorResolver {
                 /*isInline = */ false
         );
         trace.record(BindingContext.FUNCTION, method.getPsiMethod(), functionDescriptorImpl);
+        BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, method.getPsiMethod(), functionDescriptorImpl);
         FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
         if (method.getPsiMethod().getContainingClass() != psiClass && !method.isStatic()) {
             throw new IllegalStateException("non-static method in subclass");

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

@@ -88,7 +88,7 @@ public interface BindingContext {
             backingFieldRequired = valueNotFound ? false : backingFieldRequired;
             assert backingFieldRequired != null;
             // TODO: user BindingContextAccessors
-            PsiElement declarationPsiElement = map.get(DESCRIPTOR_TO_DECLARATION, propertyDescriptor);
+            PsiElement declarationPsiElement = map.get(BindingContextUtils.DESCRIPTOR_TO_DECLARATION, propertyDescriptor);
             if (declarationPsiElement instanceof JetParameter) {
                 JetParameter jetParameter = (JetParameter) declarationPsiElement;
                 return jetParameter.getValOrVarNode() != null ||
@@ -123,43 +123,19 @@ public interface BindingContext {
         }
     };
 
-    Slices.KeyNormalizer<DeclarationDescriptor> DECLARATION_DESCRIPTOR_NORMALIZER = new Slices.KeyNormalizer<DeclarationDescriptor>() {
+    WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-        @Override
+    WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-        public DeclarationDescriptor normalize(DeclarationDescriptor declarationDescriptor) {
+    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-            if (declarationDescriptor instanceof CallableMemberDescriptor) {
+    /** @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)} */
-                CallableMemberDescriptor callable = (CallableMemberDescriptor) declarationDescriptor;
+    WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.<PsiElement, SimpleFunctionDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-                if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.<PsiElement, ConstructorDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-                    Set<? extends CallableMemberDescriptor> overriddenDescriptors = callable.getOverriddenDescriptors();
+    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.<PsiElement, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-                    if (overriddenDescriptors.size() != 1) {
+    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.<JetParameter, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-                        throw new IllegalStateException(
+    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.<JetPropertyAccessor, PropertyAccessorDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-                                "cannot find declaration: fake descriptor" +
-                                " has more then one overriden descriptor: " + declarationDescriptor);
-                    }
-                    return normalize(overriddenDescriptors.iterator().next());
-                }
-            }
-            if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
-                VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
-                return descriptor.getVariableDescriptor().getOriginal();
-            }
-            return declarationDescriptor.getOriginal();
-        }
-    };
-
-    ReadOnlySlice<DeclarationDescriptor, PsiElement> DESCRIPTOR_TO_DECLARATION = Slices.<DeclarationDescriptor, PsiElement>sliceBuilder().setKeyNormalizer(DECLARATION_DESCRIPTOR_NORMALIZER).build();
-
-    WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.<PsiElement, SimpleFunctionDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.<PsiElement, ConstructorDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.<PsiElement, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.<JetParameter, VariableDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.<JetPropertyAccessor, PropertyAccessorDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
 
     // normalize value to getOriginal(value)
-    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.<PsiElement, PropertyDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.<PsiElement, PropertyDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
-    WritableSlice<JetObjectDeclarationName, PropertyDescriptor> OBJECT_DECLARATION = Slices.<JetObjectDeclarationName, PropertyDescriptor>sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<JetObjectDeclarationName, PropertyDescriptor> OBJECT_DECLARATION = Slices.<JetObjectDeclarationName, PropertyDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
 
     WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
         NAMESPACE, CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR, PRIMARY_CONSTRUCTOR_PARAMETER, OBJECT_DECLARATION

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

@@ -19,12 +19,19 @@ package org.jetbrains.jet.lang.resolve;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableAsFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
+import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
+import org.jetbrains.jet.util.slicedmap.Slices;
+
+import java.util.Set;
 
 /**
  * @author abreslav
@@ -34,6 +41,28 @@ public class BindingContextUtils {
     private BindingContextUtils() {
     }
 
+    private static final Slices.KeyNormalizer<DeclarationDescriptor> DECLARATION_DESCRIPTOR_NORMALIZER = new Slices.KeyNormalizer<DeclarationDescriptor>() {
+        @Override
+        public DeclarationDescriptor normalize(DeclarationDescriptor declarationDescriptor) {
+            if (declarationDescriptor instanceof CallableMemberDescriptor) {
+                CallableMemberDescriptor callable = (CallableMemberDescriptor) declarationDescriptor;
+                if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+                    throw new IllegalStateException("non-declaration descriptors should be filtered out earler: " + callable);
+                }
+            }
+            if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
+                VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
+                if (descriptor.getOriginal() != descriptor) {
+                    throw new IllegalStateException("original should be resolved earlier: " + descriptor);
+                }
+            }
+            return declarationDescriptor.getOriginal();
+        }
+    };
+
+    static final ReadOnlySlice<DeclarationDescriptor, PsiElement> DESCRIPTOR_TO_DECLARATION =
+            Slices.<DeclarationDescriptor, PsiElement>sliceBuilder().setKeyNormalizer(DECLARATION_DESCRIPTOR_NORMALIZER).build();
+
     @Nullable
     public static PsiElement resolveToDeclarationPsiElement(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression referenceExpression) {
         DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression);
@@ -83,10 +112,54 @@ public class BindingContextUtils {
         return context.get(BindingContext.FILE_TO_NAMESPACE, source);
     }
 
+    @Nullable
+    private static PsiElement doGetDescriptorToDeclaration(@NotNull BindingContext context, @NotNull DeclarationDescriptor descriptor) {
+        return context.get(DESCRIPTOR_TO_DECLARATION, descriptor);
+    }
+
     // NOTE this is also used by KDoc
     @Nullable
     public static PsiElement descriptorToDeclaration(@NotNull BindingContext context, @NotNull DeclarationDescriptor descriptor) {
-        return context.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor);
+        if (descriptor instanceof CallableMemberDescriptor) {
+            return callableDescriptorToDeclaration(context, (CallableMemberDescriptor) descriptor);
+        }
+        else if (descriptor instanceof ClassDescriptor) {
+            return classDescriptorToDeclaration(context, (ClassDescriptor) descriptor);
+        }
+        else {
+            return doGetDescriptorToDeclaration(context, descriptor);
+        }
     }
 
+    @Nullable
+    public static PsiElement callableDescriptorToDeclaration(@NotNull BindingContext context, @NotNull CallableMemberDescriptor callable) {
+        if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+            Set<? extends CallableMemberDescriptor> overriddenDescriptors = callable.getOverriddenDescriptors();
+            if (overriddenDescriptors.size() != 1) {
+                // TODO evil code
+                throw new IllegalStateException(
+                        "cannot find declaration: fake descriptor" +
+                                " has more then one overriden descriptor: " + callable);
+            }
+
+            return callableDescriptorToDeclaration(context, overriddenDescriptors.iterator().next());
+        }
+
+        return doGetDescriptorToDeclaration(context, callable.getOriginal());
+    }
+
+    @Nullable
+    public static PsiElement classDescriptorToDeclaration(@NotNull BindingContext context, @NotNull ClassDescriptor clazz) {
+        return doGetDescriptorToDeclaration(context, clazz);
+    }
+
+    public static void recordFunctionDeclarationToDescriptor(@NotNull BindingTrace trace,
+            @NotNull PsiElement psiElement, @NotNull SimpleFunctionDescriptor function) {
+
+        if (function.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
+            throw new IllegalArgumentException("function of kind " + function.getKind() + " cannot have declaration");
+        }
+
+        trace.record(BindingContext.FUNCTION, psiElement, function);
+    }
 }

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

@@ -179,10 +179,9 @@ public class DeclarationsChecker {
                 return;
             }
             if (!(classDescriptor.getModality() == Modality.ABSTRACT) && classDescriptor.getKind() != ClassKind.ENUM_CLASS) {
-                PsiElement classElement = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), classDescriptor);
+                JetClass classElement = (JetClass) BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor);
-                assert classElement instanceof JetClass;
                 String name = property.getName();
-                trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor, (JetClass) classElement));
+                trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor, classElement));
                 return;
             }
             if (classDescriptor.getKind() == ClassKind.TRAIT) {
@@ -252,9 +251,8 @@ public class DeclarationsChecker {
             boolean inEnum = classDescriptor.getKind() == ClassKind.ENUM_CLASS;
             boolean inAbstractClass = classDescriptor.getModality() == Modality.ABSTRACT;
             if (hasAbstractModifier && !inAbstractClass && !inTrait && !inEnum) {
-                PsiElement classElement = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), classDescriptor);
+                JetClass classElement = (JetClass) BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor);
-                assert classElement instanceof JetClass;
+                trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor, classElement));
-                trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor, (JetClass) classElement));
             }
             if (hasAbstractModifier && inTrait) {
                 trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(function));

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

@@ -230,7 +230,7 @@ public class DescriptorResolver {
                 visibility,
                 isInline);
 
-        trace.record(BindingContext.FUNCTION, function, functionDescriptor);
+        BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, function, functionDescriptor);
         return functionDescriptor;
     }
 

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

@@ -31,7 +31,6 @@ import java.util.Collection;
 import java.util.Map;
 
 import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLARATION;
 
 /**
  * @author Stepan Koltsov

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

@@ -350,7 +350,7 @@ public class TypeHierarchyResolver {
             if (!found) continue;
 
             ClassDescriptor superclass = (i < size - 1) ? currentPath.get(i + 1) : current;
-            PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), classDescriptor);
+            PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor);
 
             PsiElement elementToMark = null;
             if (psiElement instanceof JetClassOrObject) {
@@ -410,10 +410,8 @@ public class TypeHierarchyResolver {
                     if (conflictingTypes.size() > 1) {
                         DeclarationDescriptor containingDeclaration = typeParameterDescriptor.getContainingDeclaration();
                         assert containingDeclaration instanceof ClassDescriptor : containingDeclaration;
-                        PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), mutableClassDescriptor);
+                        JetClassOrObject psiElement = (JetClassOrObject) BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), mutableClassDescriptor);
-                        assert psiElement instanceof JetClassOrObject : psiElement;
+                        JetDelegationSpecifierList delegationSpecifierList = psiElement.getDelegationSpecifierList();
-                        JetClassOrObject declaration = (JetClassOrObject) psiElement;
-                        JetDelegationSpecifierList delegationSpecifierList = declaration.getDelegationSpecifierList();
                         assert delegationSpecifierList != null;
 //                        trace.getErrorHandler().genericError(delegationSpecifierList.getNode(), "Type parameter " + typeParameterDescriptor.getName() + " of " + containingDeclaration.getName() + " has inconsistent values: " + conflictingTypes);
                         trace.report(INCONSISTENT_TYPE_PARAMETER_VALUES.on(delegationSpecifierList, typeParameterDescriptor, (ClassDescriptor) containingDeclaration, conflictingTypes));

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -23,6 +23,7 @@ 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.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.ObservableBindingTrace;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -155,6 +156,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
                                       /*isInline = */ false
         );
         context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor);
+        BindingContextUtils.recordFunctionDeclarationToDescriptor(context.trace, expression, functionDescriptor);
         return functionDescriptor;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java

@@ -473,12 +473,12 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
         if (expression.getTargetLabel() == null) {
             if (containingFunctionDescriptor != null) {
-                PsiElement containingFunction = BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), containingFunctionDescriptor);
+                PsiElement containingFunction = BindingContextUtils.callableDescriptorToDeclaration(context.trace.getBindingContext(), containingFunctionDescriptor);
                 assert containingFunction != null;
                 if (containingFunction instanceof JetFunctionLiteralExpression) {
                     do {
                         containingFunctionDescriptor = DescriptorUtils.getParentOfType(containingFunctionDescriptor, FunctionDescriptor.class);
-                        containingFunction = containingFunctionDescriptor != null ? BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), containingFunctionDescriptor) : null;
+                        containingFunction = containingFunctionDescriptor != null ? BindingContextUtils.callableDescriptorToDeclaration(context.trace.getBindingContext(), containingFunctionDescriptor) : null;
                     } while (containingFunction instanceof JetFunctionLiteralExpression);
                     context.trace.report(RETURN_NOT_ALLOWED.on(expression));
                 }

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -45,7 +45,6 @@ import java.util.Collection;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLARATION;
 import static org.jetbrains.jet.lang.resolve.BindingContext.VARIABLE_REASSIGNMENT;
 
 /**

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -39,15 +39,10 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.FqName;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
-import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
-import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.plugin.project.AnalyzeSingleFileUtil;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider;
-import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
 
@@ -101,9 +96,11 @@ public class JetSourceNavigationHelper {
     public static JetClass getSourceClass(@NotNull JetClass decompiledClass) {
         Tuple2<BindingContext, ClassDescriptor> bindingContextAndClassDescriptor = getBindingContextAndClassDescriptor(decompiledClass);
         if (bindingContextAndClassDescriptor == null) return null;
-        PsiElement declaration = BindingContextUtils.descriptorToDeclaration(
+        PsiElement declaration = BindingContextUtils.classDescriptorToDeclaration(
                 bindingContextAndClassDescriptor._1, bindingContextAndClassDescriptor._2);
-        assert declaration instanceof JetClass;
+        if (declaration == null) {
+            throw new IllegalStateException("class not found by " + bindingContextAndClassDescriptor._2);
+        }
         return (JetClass) declaration;
     }
 

idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java

@@ -77,9 +77,9 @@ class JetArrayAccessReference extends JetPsiReference implements MultiRangeRefer
         if (getFunction == null || setFunction == null) {
             return new ResolveResult[0];
         }
-        PsiElement getFunctionElement = BindingContextUtils.descriptorToDeclaration(bindingContext, getFunction.getResultingDescriptor());
+        PsiElement getFunctionElement = BindingContextUtils.callableDescriptorToDeclaration(bindingContext, getFunction.getResultingDescriptor());
         assert getFunctionElement != null;
-        PsiElement setFunctionElement = BindingContextUtils.descriptorToDeclaration(bindingContext, setFunction.getResultingDescriptor());
+        PsiElement setFunctionElement = BindingContextUtils.callableDescriptorToDeclaration(bindingContext, setFunction.getResultingDescriptor());
         assert setFunctionElement != null;
         return new ResolveResult[] {new PsiElementResolveResult(getFunctionElement, true), new PsiElementResolveResult(setFunctionElement, true)};
     }

idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java

@@ -35,7 +35,6 @@ import java.util.ArrayList;
 import java.util.Collection;
 
 import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DESCRIPTOR_TO_DECLARATION;
 
 public abstract class JetPsiReference implements PsiPolyVariantReference {
 

idea/tests/org/jetbrains/jet/plugin/refactoring/rename/RenameInKotlinTest.java

@@ -27,6 +27,7 @@ import com.intellij.refactoring.MultiFileTestCase;
 import com.intellij.refactoring.rename.RenameProcessor;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.FqName;
@@ -70,7 +71,7 @@ public class RenameInKotlinTest extends MultiFileTestCase {
 
                 assertNotNull(classDescriptor);
 
-                PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(bindingContext, classDescriptor);
+                PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(bindingContext, classDescriptor);
 
                 assertNotNull(psiElement);
 

js/js.translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java

@@ -89,15 +89,17 @@ public final class BindingUtils {
     @NotNull
     public static JetClass getClassForDescriptor(@NotNull BindingContext context,
                                                  @NotNull ClassDescriptor descriptor) {
-        PsiElement result = BindingContextUtils.descriptorToDeclaration(context, descriptor);
+        JetClass result = (JetClass) BindingContextUtils.classDescriptorToDeclaration(context, descriptor);
-        assert result instanceof JetClass : "ClassDescriptor should have declaration of type JetClass";
+        if (result == null) {
-        return (JetClass)result;
+            throw new IllegalStateException("JetClass not found for " + descriptor);
+        }
+        return result;
     }
 
     @NotNull
     public static JetFunction getFunctionForDescriptor(@NotNull BindingContext context,
                                                        @NotNull SimpleFunctionDescriptor descriptor) {
-        PsiElement result = BindingContextUtils.descriptorToDeclaration(context, descriptor);
+        PsiElement result = BindingContextUtils.callableDescriptorToDeclaration(context, descriptor);
         assert result instanceof JetFunction : "SimpleFunctionDescriptor should have declaration of type JetFunction";
         return (JetFunction)result;
     }