From 1c147182145e881469ddf8ad48981bc03d6b7028 Mon Sep 17 00:00:00 2001
From: Andrey Breslav <abreslav@abreslav-mac.labs.intellij.net>
Date: Wed, 23 Nov 2011 20:37:22 +0300
Subject: [PATCH] Class renamed to better reflect it's purpose

---
 .idea/compiler.xml                            |  2 +-
 .../jet/lang/JetSemanticServices.java         |  6 +++---
 .../jet/lang/resolve/BodyResolver.java        |  8 ++++----
 .../jet/lang/resolve/DeclarationResolver.java | 14 ++++++-------
 .../jet/lang/resolve/DeclarationsChecker.java |  2 +-
 ...rResolver.java => DescriptorResolver.java} |  4 ++--
 .../lang/resolve/TopDownAnalysisContext.java  |  8 ++++----
 .../lang/resolve/TypeHierarchyResolver.java   | 18 ++++++++---------
 .../ClosureExpressionsTypingVisitor.java      |  2 +-
 .../ControlStructureTypingVisitor.java        |  6 +++---
 .../expressions/ExpressionTypingContext.java  | 12 +++++------
 .../ExpressionTypingVisitorForStatements.java |  6 +++---
 .../PatternMatchingTypingVisitor.java         |  2 +-
 .../JetDefaultModalityModifiersTest.java      | 14 ++++++-------
 .../jetbrains/jet/types/JetOverloadTest.java  |  8 ++++----
 .../jet/types/JetOverridingTest.java          |  8 ++++----
 .../jet/types/JetTypeCheckerTest.java         | 20 +++++++++----------
 17 files changed, 70 insertions(+), 70 deletions(-)
 rename compiler/frontend/src/org/jetbrains/jet/lang/resolve/{ClassDescriptorResolver.java => DescriptorResolver.java} (99%)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index fb3e2a37c80..1397a2192d0 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <option name="DEFAULT_COMPILER" value="Eclipse" />
+    <option name="DEFAULT_COMPILER" value="Javac" />
     <resourceExtensions />
     <wildcardResourcePatterns>
       <entry name="?*.properties" />
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
index c666125cd19..9a92d86c8d0 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java
@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -38,8 +38,8 @@ public class JetSemanticServices {
     }
 
     @NotNull
-    public ClassDescriptorResolver getClassDescriptorResolver(BindingTrace trace) {
-        return new ClassDescriptorResolver(this, trace);
+    public DescriptorResolver getClassDescriptorResolver(BindingTrace trace) {
+        return new DescriptorResolver(this, trace);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
index 7637f611a8e..dd45fdd7af9 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
@@ -357,8 +357,8 @@ public class BodyResolver {
         }
         JetExpression bodyExpression = declaration.getBodyExpression();
         if (bodyExpression != null) {
-            //context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
-            //JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
+            //context.getDescriptorResolver().computeFlowData(declaration, bodyExpression);
+            //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(declaration, bodyExpression);
             ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
 
             typeInferrer.checkFunctionReturnType(functionInnerScope, declaration, JetStandardClasses.getUnitType());
@@ -482,7 +482,7 @@ public class BodyResolver {
     }
 
     private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) {
-        //JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15
+        //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15
         ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
         JetType expectedTypeForInitializer = property.getPropertyTypeRef() != null ? propertyDescriptor.getOutType() : NO_EXPECTED_TYPE;
         JetType type = typeInferrer.getType(getPropertyDeclarationInnerScope(scope, propertyDescriptor), initializer, expectedTypeForInitializer);
@@ -532,7 +532,7 @@ public class BodyResolver {
 
         JetExpression bodyExpression = function.getBodyExpression();
         if (bodyExpression != null) {
-            //JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(function.asElement(), bodyExpression);
+            //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(function.asElement(), bodyExpression);
             ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace);
 
             typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptor);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
index 84f80ad1328..8c645412d1f 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
@@ -94,7 +94,7 @@ public class DeclarationResolver {
             declaration.accept(new JetVisitorVoid() {
                 @Override
                 public void visitNamedFunction(JetNamedFunction function) {
-                    FunctionDescriptorImpl functionDescriptor = context.getClassDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scope, function);
+                    FunctionDescriptorImpl functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scope, function);
                     namespaceLike.addFunctionDescriptor(functionDescriptor);
                     context.getFunctions().put(function, functionDescriptor);
                     context.getDeclaringScopes().put(function, scope);
@@ -102,7 +102,7 @@ public class DeclarationResolver {
 
                 @Override
                 public void visitProperty(JetProperty property) {
-                    PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolvePropertyDescriptor(namespaceLike, scope, property);
+                    PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolvePropertyDescriptor(namespaceLike, scope, property);
                     namespaceLike.addPropertyDescriptor(propertyDescriptor);
                     context.getProperties().put(property, propertyDescriptor);
                     context.getDeclaringScopes().put(property, scope);
@@ -110,7 +110,7 @@ public class DeclarationResolver {
 
                 @Override
                 public void visitObjectDeclaration(JetObjectDeclaration declaration) {
-                    PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, context.getObjects().get(declaration));
+                    PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(namespaceLike, declaration, context.getObjects().get(declaration));
                     namespaceLike.addPropertyDescriptor(propertyDescriptor);
                 }
 
@@ -119,7 +119,7 @@ public class DeclarationResolver {
                     if (enumEntry.getPrimaryConstructorParameterList() == null) {
                         MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) namespaceLike).getClassObjectDescriptor();
                         assert classObjectDescriptor != null;
-                        PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry));
+                        PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry));
                         classObjectDescriptor.addPropertyDescriptor(propertyDescriptor);
                     }
                 }
@@ -137,10 +137,10 @@ public class DeclarationResolver {
 
         // TODO : not all the parameters are real properties
         JetScope memberScope = classDescriptor.getScopeForSupertypeResolution();
-        ConstructorDescriptor constructorDescriptor = context.getClassDescriptorResolver().resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass);
+        ConstructorDescriptor constructorDescriptor = context.getDescriptorResolver().resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass);
         for (JetParameter parameter : klass.getPrimaryConstructorParameters()) {
             if (parameter.getValOrVarNode() != null) {
-                PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
+                PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
                         classDescriptor,
                         memberScope,
                         parameter
@@ -159,7 +159,7 @@ public class DeclarationResolver {
 //            context.getTrace().getErrorHandler().genericError(constructor.getNameNode(), "A trait may not have a constructor");
             context.getTrace().report(CONSTRUCTOR_IN_TRAIT.on(constructor.getNameNode()));
         }
-        ConstructorDescriptor constructorDescriptor = context.getClassDescriptorResolver().resolveSecondaryConstructorDescriptor(
+        ConstructorDescriptor constructorDescriptor = context.getDescriptorResolver().resolveSecondaryConstructorDescriptor(
                 classDescriptor.getScopeForMemberResolution(),
                 classDescriptor,
                 constructor);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
index 8a7beb5a7f8..34e55786dbc 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
@@ -149,7 +149,7 @@ public class DeclarationsChecker {
         PsiElement nameIdentifier = member.getNameIdentifier();
         boolean hasDeferredType;
         if (member instanceof JetProperty) {
-            hasDeferredType = ((JetProperty) member).getPropertyTypeRef() == null && ClassDescriptorResolver.hasBody((JetProperty) member);
+            hasDeferredType = ((JetProperty) member).getPropertyTypeRef() == null && DescriptorResolver.hasBody((JetProperty) member);
         }
         else {
             assert member instanceof JetFunction;
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
similarity index 99%
rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
index 3de809f0f8b..7367a1fbd20 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
@@ -27,14 +27,14 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 /**
  * @author abreslav
  */
-public class ClassDescriptorResolver {
+public class DescriptorResolver {
     private final JetSemanticServices semanticServices;
     private final TypeResolver typeResolver;
     private final TypeResolver typeResolverNotCheckingBounds;
     private final BindingTrace trace;
     private final AnnotationResolver annotationResolver;
 
-    public ClassDescriptorResolver(JetSemanticServices semanticServices, BindingTrace trace) {
+    public DescriptorResolver(JetSemanticServices semanticServices, BindingTrace trace) {
         this.semanticServices = semanticServices;
         this.typeResolver = new TypeResolver(semanticServices, trace, true);
         this.typeResolverNotCheckingBounds = new TypeResolver(semanticServices, trace, false);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
index f03bfdbd5c7..96483be60c3 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
@@ -23,7 +23,7 @@ import java.util.Set;
 
     private final ObservableBindingTrace trace;
     private final JetSemanticServices semanticServices;
-    private final ClassDescriptorResolver classDescriptorResolver;
+    private final DescriptorResolver descriptorResolver;
 
     private final Map<JetClass, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
     private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
@@ -46,7 +46,7 @@ import java.util.Set;
     public TopDownAnalysisContext(JetSemanticServices semanticServices, BindingTrace trace, Predicate<PsiFile> analyzeCompletely) {
         this.trace = new ObservableBindingTrace(trace);
         this.semanticServices = semanticServices;
-        this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace);
+        this.descriptorResolver = semanticServices.getClassDescriptorResolver(trace);
         this.analyzeCompletely = analyzeCompletely;
     }
 
@@ -93,8 +93,8 @@ import java.util.Set;
         return semanticServices;
     }
 
-    public ClassDescriptorResolver getClassDescriptorResolver() {
-        return classDescriptorResolver;
+    public DescriptorResolver getDescriptorResolver() {
+        return descriptorResolver;
     }
 
     public Map<JetClass, MutableClassDescriptor> getClasses() {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
index 7cc40628441..2585e655d35 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
@@ -101,7 +101,7 @@ public class TypeHierarchyResolver {
                         MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(context.getTrace(), mutableClassDescriptor, outerScope, ClassKind.OBJECT);
                         classObjectDescriptor.setName("class-object-for-" + klass.getName());
                         classObjectDescriptor.setModality(Modality.FINAL);
-                        classObjectDescriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(klass.getModifierList()));
+                        classObjectDescriptor.setVisibility(DescriptorResolver.resolveVisibilityFromModifiers(klass.getModifierList()));
                         classObjectDescriptor.createTypeConstructor();
                         createPrimaryConstructorForObject(null, classObjectDescriptor);
                         mutableClassDescriptor.setClassObjectDescriptor(classObjectDescriptor);
@@ -290,14 +290,14 @@ public class TypeHierarchyResolver {
         for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             JetClass jetClass = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
-            context.getClassDescriptorResolver().resolveMutableClassDescriptor(jetClass, descriptor);
+            context.getDescriptorResolver().resolveMutableClassDescriptor(jetClass, descriptor);
             descriptor.createTypeConstructor();
         }
         for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
             JetObjectDeclaration objectDeclaration = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
             descriptor.setModality(Modality.FINAL);
-            descriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(objectDeclaration.getModifierList()));
+            descriptor.setVisibility(DescriptorResolver.resolveVisibilityFromModifiers(objectDeclaration.getModifierList()));
             descriptor.createTypeConstructor();
         }
     }
@@ -306,13 +306,13 @@ public class TypeHierarchyResolver {
         for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             JetClass jetClass = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
-            context.getClassDescriptorResolver().resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters());
-            context.getClassDescriptorResolver().resolveSupertypes(jetClass, descriptor);
+            context.getDescriptorResolver().resolveGenericBounds(jetClass, descriptor.getScopeForSupertypeResolution(), descriptor.getTypeConstructor().getParameters());
+            context.getDescriptorResolver().resolveSupertypes(jetClass, descriptor);
         }
         for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
             JetClassOrObject jetClass = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
-            context.getClassDescriptorResolver().resolveSupertypes(jetClass, descriptor);
+            context.getDescriptorResolver().resolveSupertypes(jetClass, descriptor);
         }
     }
 
@@ -517,7 +517,7 @@ public class TypeHierarchyResolver {
                 if (typeReference != null) {
                     JetType type = context.getTrace().getBindingContext().get(TYPE, typeReference);
                     if (type != null) {
-                        context.getClassDescriptorResolver().checkBounds(typeReference, type);
+                        context.getDescriptorResolver().checkBounds(typeReference, type);
                     }
                 }
             }
@@ -527,7 +527,7 @@ public class TypeHierarchyResolver {
                 if (extendsBound != null) {
                     JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound);
                     if (type != null) {
-                        context.getClassDescriptorResolver().checkBounds(extendsBound, type);
+                        context.getDescriptorResolver().checkBounds(extendsBound, type);
                     }
                 }
             }
@@ -537,7 +537,7 @@ public class TypeHierarchyResolver {
                 if (extendsBound != null) {
                     JetType type = context.getTrace().getBindingContext().get(TYPE, extendsBound);
                     if (type != null) {
-                        context.getClassDescriptorResolver().checkBounds(extendsBound, type);
+                        context.getDescriptorResolver().checkBounds(extendsBound, type);
                     }
                 }
             }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java
index 8add070d296..24fb25be067 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java
@@ -168,7 +168,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
                         type = ErrorUtils.createErrorType("Cannot be inferred");
                     }
                 }
-                ValueParameterDescriptor valueParameterDescriptor = context.getClassDescriptorResolver().resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type);
+                ValueParameterDescriptor valueParameterDescriptor = context.getDescriptorResolver().resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type);
                 valueParameterDescriptors.add(valueParameterDescriptor);
             }
         }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java
index e0e1a312e70..d260b7ef9e3 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java
@@ -197,7 +197,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             JetTypeReference typeReference = loopParameter.getTypeReference();
             VariableDescriptor variableDescriptor;
             if (typeReference != null) {
-                variableDescriptor = context.getClassDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, loopParameter);
+                variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, loopParameter);
                 JetType actualParameterType = variableDescriptor.getOutType();
                 if (expectedParameterType != null &&
                         actualParameterType != null &&
@@ -209,7 +209,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                 if (expectedParameterType == null) {
                     expectedParameterType = ErrorUtils.createErrorType("Error");
                 }
-                variableDescriptor = context.getClassDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), loopParameter, expectedParameterType);
+                variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), loopParameter, expectedParameterType);
             }
             loopScope.addVariableDescriptor(variableDescriptor);
         }
@@ -320,7 +320,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             JetParameter catchParameter = catchClause.getCatchParameter();
             JetExpression catchBody = catchClause.getCatchBody();
             if (catchParameter != null) {
-                VariableDescriptor variableDescriptor = context.getClassDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, catchParameter);
+                VariableDescriptor variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, catchParameter);
                 if (catchBody != null) {
                     WritableScope catchScope = newWritableScopeImpl(context).setDebugName("Catch scope");
                     catchScope.addVariableDescriptor(variableDescriptor);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java
index f81094254b2..9dcd5d3d314 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java
@@ -8,7 +8,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallMaker;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -71,7 +71,7 @@ import java.util.Map;
 
     private CallResolver callResolver;
     private TypeResolver typeResolver;
-    private ClassDescriptorResolver classDescriptorResolver;
+    private DescriptorResolver descriptorResolver;
     private ExpressionTypingServices services;
     private CompileTimeConstantResolver compileTimeConstantResolver;
 
@@ -156,11 +156,11 @@ import java.util.Map;
         return typeResolver;
     }
 
-    public ClassDescriptorResolver getClassDescriptorResolver() {
-        if (classDescriptorResolver == null) {
-            classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace);
+    public DescriptorResolver getDescriptorResolver() {
+        if (descriptorResolver == null) {
+            descriptorResolver = semanticServices.getClassDescriptorResolver(trace);
         }
-        return classDescriptorResolver;
+        return descriptorResolver;
     }
 
     public CompileTimeConstantResolver getCompileTimeConstantResolver() {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
index 718f668f1fe..68704d336ee 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java
@@ -59,7 +59,7 @@ public class ExpressionTypingVisitorForStatements extends BasicExpressionTypingV
         TopDownAnalyzer.processObject(context.semanticServices, context.trace, scope, scope.getContainingDeclaration(), declaration);
         ClassDescriptor classDescriptor = context.trace.getBindingContext().get(BindingContext.CLASS, declaration);
         if (classDescriptor != null) {
-            PropertyDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(scope.getContainingDeclaration(), declaration, classDescriptor);
+            PropertyDescriptor propertyDescriptor = context.getDescriptorResolver().resolveObjectDeclarationAsPropertyDescriptor(scope.getContainingDeclaration(), declaration, classDescriptor);
             scope.addVariableDescriptor(propertyDescriptor);
         }
         return checkExpectedType(declaration, context);
@@ -82,7 +82,7 @@ public class ExpressionTypingVisitorForStatements extends BasicExpressionTypingV
             context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
         }
 
-        VariableDescriptor propertyDescriptor = context.getClassDescriptorResolver().resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property);
+        VariableDescriptor propertyDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property);
         JetExpression initializer = property.getInitializer();
         if (property.getPropertyTypeRef() != null && initializer != null) {
             JetType outType = propertyDescriptor.getOutType();
@@ -95,7 +95,7 @@ public class ExpressionTypingVisitorForStatements extends BasicExpressionTypingV
 
     @Override
     public JetType visitNamedFunction(JetNamedFunction function, ExpressionTypingContext context) {
-        FunctionDescriptorImpl functionDescriptor = context.getClassDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function);
+        FunctionDescriptorImpl functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function);
         scope.addFunctionDescriptor(functionDescriptor);
         context.getServices().checkFunctionReturnType(context.scope, function, functionDescriptor, context.dataFlowInfo);
         return checkExpectedType(function, context);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java
index 86bc4e82677..9a7c4d968c3 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java
@@ -228,7 +228,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
                 JetProperty variableDeclaration = pattern.getVariableDeclaration();
                 JetTypeReference propertyTypeRef = variableDeclaration.getPropertyTypeRef();
                 JetType type = propertyTypeRef == null ? subjectType : context.getTypeResolver().resolveType(context.scope, propertyTypeRef);
-                VariableDescriptor variableDescriptor = context.getClassDescriptorResolver().resolveLocalVariableDescriptorWithType(context.scope.getContainingDeclaration(), variableDeclaration, type);
+                VariableDescriptor variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptorWithType(context.scope.getContainingDeclaration(), variableDeclaration, type);
                 scopeToExtend.addVariableDescriptor(variableDescriptor);
                 if (propertyTypeRef != null) {
                     if (!context.semanticServices.getTypeChecker().isSubtypeOf(subjectType, type)) {
diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
index bb86813770e..fb9556a89c3 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
@@ -6,7 +6,7 @@ import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
@@ -29,13 +29,13 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
     public class JetDefaultModalityModifiersTestCase  {
         private ModuleDescriptor root = new ModuleDescriptor("test_root");
-        private ClassDescriptorResolver classDescriptorResolver;
+        private DescriptorResolver descriptorResolver;
         private JetScope scope;
 
         public void setUp() throws Exception {
             JetStandardLibrary library = JetStandardLibrary.getJetStandardLibrary(getProject());
             JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(library);
-            classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE);
+            descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE);
             scope = createScope(library.getLibraryScope());
         }
 
@@ -54,7 +54,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private MutableClassDescriptor createClassDescriptor(ClassKind kind, JetClass aClass) {
             MutableClassDescriptor classDescriptor = new MutableClassDescriptor(JetTestUtils.DUMMY_TRACE, root, scope, kind);
-            classDescriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor);
+            descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor);
             return classDescriptor;
         }
 
@@ -72,7 +72,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetNamedFunction function = (JetNamedFunction) declarations.get(0);
-            FunctionDescriptorImpl functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
+            FunctionDescriptorImpl functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
 
             assertEquals(expectedFunctionModality, functionDescriptor.getModality());
         }
@@ -83,7 +83,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetProperty property = (JetProperty) declarations.get(0);
-            PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
+            PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
 
             assertEquals(expectedPropertyModality, propertyDescriptor.getModality());
         }
@@ -95,7 +95,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetProperty property = (JetProperty) declarations.get(0);
-            PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
+            PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
             PropertyAccessorDescriptor propertyAccessor = isGetter
                                                           ? propertyDescriptor.getGetter()
                                                           : propertyDescriptor.getSetter();
diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
index eb7a016e836..00631f8d26a 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
@@ -8,7 +8,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
-import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverloadUtil;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 
@@ -20,14 +20,14 @@ public class JetOverloadTest extends JetLiteFixture {
     private ModuleDescriptor root = new ModuleDescriptor("test_root");
     private JetStandardLibrary library;
     private JetSemanticServices semanticServices;
-    private ClassDescriptorResolver classDescriptorResolver;
+    private DescriptorResolver descriptorResolver;
 
     @Override
     public void setUp() throws Exception {
         super.setUp();
         library          = JetStandardLibrary.getJetStandardLibrary(getProject());
         semanticServices = JetSemanticServices.createSemanticServices(library);
-        classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
+        descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
     }
 
     @Override
@@ -152,7 +152,7 @@ public class JetOverloadTest extends JetLiteFixture {
 
     private FunctionDescriptor makeFunction(String funDecl) {
         JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl);
-        return classDescriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
+        return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
     }
 
 }
diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
index 18b27921f61..6053d5ecc59 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
@@ -8,7 +8,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
-import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 
@@ -20,14 +20,14 @@ public class JetOverridingTest extends JetLiteFixture {
     private ModuleDescriptor root = new ModuleDescriptor("test_root");
     private JetStandardLibrary library;
     private JetSemanticServices semanticServices;
-    private ClassDescriptorResolver classDescriptorResolver;
+    private DescriptorResolver descriptorResolver;
 
     @Override
     public void setUp() throws Exception {
         super.setUp();
         library          = JetStandardLibrary.getJetStandardLibrary(getProject());
         semanticServices = JetSemanticServices.createSemanticServices(library);
-        classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
+        descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
     }
 
     @Override
@@ -145,6 +145,6 @@ public class JetOverridingTest extends JetLiteFixture {
 
     private FunctionDescriptor makeFunction(String funDecl) {
         JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl);
-        return classDescriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
+        return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
     }
 }
diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
index 66941d6ac14..bc2d5e09fa3 100644
--- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
@@ -30,7 +30,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     private JetStandardLibrary library;
     private JetSemanticServices semanticServices;
     private ClassDefinitions classDefinitions;
-    private ClassDescriptorResolver classDescriptorResolver;
+    private DescriptorResolver descriptorResolver;
     private JetScope scopeWithImports;
     private TypeResolver typeResolver;
 
@@ -44,7 +44,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         library          = JetStandardLibrary.getJetStandardLibrary(getProject());
         semanticServices = JetSemanticServices.createSemanticServices(library);
         classDefinitions = new ClassDefinitions();
-        classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
+        descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
         scopeWithImports = addImports(classDefinitions.BASIC_SCOPE);
         typeResolver = new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true);
     }
@@ -604,7 +604,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                 Set<FunctionDescriptor> writableFunctionGroup = Sets.newLinkedHashSet();
                 ModuleDescriptor module = new ModuleDescriptor("TypeCheckerTest");
                 for (String funDecl : FUNCTION_DECLARATIONS) {
-                    FunctionDescriptor functionDescriptor = classDescriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl));
+                    FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl));
                     if (name.equals(functionDescriptor.getName())) {
                         writableFunctionGroup.add(functionDescriptor);
                     }
@@ -628,14 +628,14 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
             // This call has side-effects on the parameterScope (fills it in)
             List<TypeParameterDescriptor> typeParameters
-                    = classDescriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
-            classDescriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters);
+                    = descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
+            descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters);
 
             List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
             // TODO : assuming that the hierarchy is acyclic
             Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
                     ? Collections.singleton(JetStandardClasses.getAnyType())
-                    : classDescriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
+                    : descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
     //        for (JetType supertype: supertypes) {
     //            if (supertype.getConstructor().isSealed()) {
     //                trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype);
@@ -651,7 +651,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                     @Override
                     public void visitProperty(JetProperty property) {
                         if (property.getPropertyTypeRef() != null) {
-                            memberDeclarations.addVariableDescriptor(classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property));
+                            memberDeclarations.addVariableDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property));
                         } else {
                             // TODO : Caution: a cyclic dependency possible
                             throw new UnsupportedOperationException();
@@ -661,7 +661,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                     @Override
                     public void visitNamedFunction(JetNamedFunction function) {
                         if (function.getReturnTypeRef() != null) {
-                            memberDeclarations.addFunctionDescriptor(classDescriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function));
+                            memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function));
                         } else {
                             // TODO : Caution: a cyclic dependency possible
                             throw new UnsupportedOperationException();
@@ -685,11 +685,11 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                     null
             );
             for (JetSecondaryConstructor constructor : classElement.getSecondaryConstructors()) {
-                ConstructorDescriptorImpl functionDescriptor = classDescriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
+                ConstructorDescriptorImpl functionDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
                 functionDescriptor.setReturnType(classDescriptor.getDefaultType());
                 constructors.add(functionDescriptor);
             }
-            ConstructorDescriptorImpl primaryConstructorDescriptor = classDescriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
+            ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
             if (primaryConstructorDescriptor != null) {
                 primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
                 constructors.add(primaryConstructorDescriptor);