Visitors refactored. LabelResolver problem stays there

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

@@ -94,7 +94,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
 
     public StackValue genQualified(StackValue receiver, JetElement selector) {
         markLineNumber(selector);
-        return selector.visit(this, receiver);
+        return selector.accept(this, receiver);
     }
 
     public StackValue gen(JetElement expr) {

compiler/frontend/src/org/jetbrains/jet/lang/JetSemanticServices.java

@@ -7,7 +7,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.JetTypeChecker;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTyperServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 
 /**
  * @author abreslav
@@ -46,8 +46,8 @@ public class JetSemanticServices {
     }
 
     @NotNull
-    public ExpressionTyperServices getTypeInferrerServices(@NotNull BindingTrace trace) {
-        return new ExpressionTyperServices(this, trace);
+    public ExpressionTypingServices getTypeInferrerServices(@NotNull BindingTrace trace) {
+        return new ExpressionTypingServices(this, trace);
     }
 
     @NotNull

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

@@ -22,7 +22,7 @@ public class JetAnnotatedExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotatedExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetAnnotation extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotation(this, data);
     }
 

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

@@ -22,7 +22,7 @@ public class JetAnnotationEntry extends JetElement implements JetCallElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitAnnotationEntry(this, data);
     }
 

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

@@ -32,7 +32,7 @@ public class JetArrayAccessExpression extends JetReferenceExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitArrayAccessExpression(this, data);
     }
 

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

@@ -21,7 +21,7 @@ public class JetBinaryExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBinaryExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetBinaryExpressionWithTypeRHS extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBinaryWithTypeRHSExpression(this, data);
     }
 

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

@@ -29,7 +29,7 @@ public class JetBindingPattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBindingPattern(this, data);
     }
 }

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

@@ -20,7 +20,7 @@ public class JetBlockExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBlockExpression(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetBlockStringTemplateEntry extends JetStringTemplateEntryWithExpre
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBlockStringTemplateEntry(this, data);
     }
 }

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

@@ -17,7 +17,7 @@ public class JetBreakExpression extends JetLabelQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitBreakExpression(this, data);
     }
 }

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

@@ -22,7 +22,7 @@ public class JetCallExpression extends JetExpression implements JetCallElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitCallExpression(this, data);
     }
 

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

@@ -21,7 +21,7 @@ public class JetCatchClause extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitCatchSection(this, data);
     }
 

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

@@ -40,7 +40,7 @@ public class JetClass extends JetTypeParameterListOwner implements JetClassOrObj
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitClass(this, data);
     }
 

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

@@ -30,7 +30,7 @@ public class JetClassBody extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitClassBody(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetClassInitializer extends JetDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitAnonymousInitializer(this, data);
     }
 

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

@@ -19,7 +19,7 @@ public class JetClassObject extends JetDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitClassObject(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetConstantExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitConstantExpression(this, data);
     }
 }

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

@@ -23,7 +23,7 @@ public class JetConstructor extends JetDeclaration implements JetDeclarationWith
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitConstructor(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetContinueExpression extends JetLabelQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitContinueExpression(this, data);
     }
 }

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

@@ -28,7 +28,7 @@ public class JetDecomposerPattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDecomposerPattern(this, data);
     }
 }

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

@@ -19,7 +19,7 @@ public class JetDelegationSpecifier extends JetElement{
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationSpecifier(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetDelegationSpecifierList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationSpecifierList(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public class JetDelegatorByExpressionSpecifier extends JetDelegationSpecifier {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationByExpressionSpecifier(this, data);
     }
 

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

@@ -22,7 +22,7 @@ public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements J
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationToSuperCallSpecifier(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetDelegatorToSuperClass extends JetDelegationSpecifier {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationToSuperClassSpecifier(this, data);
     }
 }

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

@@ -23,7 +23,7 @@ public class JetDelegatorToThisCall extends JetDelegationSpecifier implements Je
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDelegationToThisCall(this, data);
     }
 

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

@@ -19,7 +19,7 @@ public class JetDoWhileExpression extends JetLoopExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDoWhileExpression(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetDotQualifiedExpression extends JetQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitDotQualifiedExpression(this, data);
     }
 }

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

@@ -52,7 +52,7 @@ public class JetElement extends ASTWrapperPsiElement {
         visitor.visitJetElement(this);
     }
     
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitJetElement(this, data);
     }
 }

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

@@ -52,7 +52,7 @@ public class JetEnumEntry extends JetClass {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitEnumEntry(this, data);
     }
 }

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

@@ -18,7 +18,7 @@ public class JetEscapeStringTemplateEntry extends JetStringTemplateEntry {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitEscapeStringTemplateEntry(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public abstract class JetExpression extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitExpression(this, data);
     }
 

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

@@ -23,7 +23,7 @@ public class JetExpressionPattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitExpressionPattern(this, data);
     }
 }

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

@@ -18,7 +18,7 @@ public class JetFinallySection extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitFinallySection(this, data);
     }
 

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

@@ -19,7 +19,7 @@ public class JetForExpression extends JetLoopExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitForExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetFunctionLiteralExpression extends JetExpression implements JetDe
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitFunctionLiteralExpression(this, data);
     }
 

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

@@ -45,7 +45,7 @@ public class JetFunctionType extends JetTypeElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitFunctionType(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetHashQualifiedExpression extends JetQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitHashQualifiedExpression(this, data);
     }
 }

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

@@ -19,7 +19,7 @@ public class JetIfExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitIfExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetImportDirective extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitImportDirective(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetInitializerList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitInitializerList(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetIsExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitIsExpression(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetLiteralStringTemplateEntry extends JetStringTemplateEntry {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitLiteralStringTemplateEntry(this, data);
     }
 }

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

@@ -25,7 +25,7 @@ public class JetModifierList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitModifierList(this, data);
     }
 

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

@@ -19,7 +19,7 @@ public class JetNamedFunction extends JetFunction {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitNamedFunction(this, data);
     }
 

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

@@ -24,7 +24,7 @@ public class JetNamespace extends JetNamedDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitNamespace(this, data);
     }
 

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

@@ -24,7 +24,7 @@ public class JetNamespaceBody extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitNamespaceBody(this, data);
     }
 }

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

@@ -31,7 +31,7 @@ public class JetNullableType extends JetTypeElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitNullableType(this, data);
     }
 

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

@@ -84,7 +84,7 @@ public class JetObjectDeclaration extends JetNamedDeclaration implements JetClas
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitObjectDeclaration(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public class JetObjectLiteralExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitObjectLiteralExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetParameter extends JetNamedDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitParameter(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetParameterList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitParameterList(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public class JetParenthesizedExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitParenthesizedExpression(this, data);
     }
 

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

@@ -24,7 +24,7 @@ public class JetPostfixExpression extends JetUnaryExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitPostfixExpression(this, data);
     }
 }

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

@@ -17,7 +17,7 @@ public class JetPredicateExpression extends JetQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitPredicateExpression(this, data);
     }
 }

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

@@ -19,7 +19,7 @@ public class JetPrefixExpression extends JetUnaryExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitPrefixExpression(this, data);
     }
 

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

@@ -31,7 +31,7 @@ public class JetProperty extends JetTypeParameterListOwner implements JetModifie
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitProperty(this, data);
     }
 

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

@@ -24,7 +24,7 @@ public class JetPropertyAccessor extends JetDeclaration implements JetDeclaratio
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitPropertyAccessor(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public class JetReturnExpression extends JetLabelQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitReturnExpression(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetRootNamespaceExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitRootNamespaceExpression(this, data);
     }
 }

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

@@ -17,7 +17,7 @@ public class JetSafeQualifiedExpression extends JetQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitSafeQualifiedExpression(this, data);
     }
 }

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

@@ -26,7 +26,7 @@ public class JetSelfType extends JetTypeElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitSelfType(this, data);
     }
 }

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

@@ -62,7 +62,7 @@ public class JetSimpleNameExpression extends JetReferenceExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitSimpleNameExpression(this, data);
     }
 }

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

@@ -18,7 +18,7 @@ public class JetSimpleNameStringTemplateEntry extends JetStringTemplateEntryWith
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitSimpleNameStringTemplateEntry(this, data);
     }
 }

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

@@ -17,7 +17,7 @@ public abstract class JetStringTemplateEntryWithExpression extends JetStringTemp
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitStringTemplateEntryWithExpression(this, data);
     }
 }

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

@@ -17,7 +17,7 @@ public class JetStringTemplateExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitStringTemplateExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetThisExpression extends JetLabelQualifiedExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitThisExpression(this, data);
     }
 

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

@@ -18,7 +18,7 @@ public class JetThrowExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitThrowExpression(this, data);
     }
 

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

@@ -10,11 +10,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitNamespace(JetNamespace namespace, D data) {
         List<JetImportDirective> importDirectives = namespace.getImportDirectives();
         for (JetImportDirective directive : importDirectives) {
-            directive.visit(this, data);
+            directive.accept(this, data);
         }
         List<JetDeclaration> declarations = namespace.getDeclarations();
         for (JetDeclaration declaration : declarations) {
-            declaration.visit(this, data);
+            declaration.accept(this, data);
         }
         return null;
     }
@@ -23,7 +23,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitClass(JetClass klass, D data) {
         List<JetDeclaration> declarations = klass.getDeclarations();
         for (JetDeclaration declaration : declarations) {
-            declaration.visit(this, data);
+            declaration.accept(this, data);
         }
         return null;
     }
@@ -32,7 +32,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitClassObject(JetClassObject classObject, D data) {
         JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
         if (objectDeclaration != null) {
-            objectDeclaration.visit(this, data);
+            objectDeclaration.accept(this, data);
         }
         return null;
     }
@@ -53,11 +53,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitProperty(JetProperty property, D data) {
         List<JetPropertyAccessor> accessors = property.getAccessors();
         for (JetPropertyAccessor accessor : accessors) {
-            accessor.visit(this, data);
+            accessor.accept(this, data);
         }
         JetExpression initializer = property.getInitializer();
         if (initializer != null) {
-            initializer.visit(this, data);
+            initializer.accept(this, data);
         }
         return null;
     }
@@ -70,7 +70,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitJetFile(JetFile file, D data) {
         JetNamespace rootNamespace = file.getRootNamespace();
-        return rootNamespace.visit(this, data);
+        return rootNamespace.accept(this, data);
     }
 
     @Override
@@ -82,11 +82,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitClassBody(JetClassBody classBody, D data) {
         List<JetDeclaration> declarations = classBody.getDeclarations();
         for (JetDeclaration declaration : declarations) {
-            declaration.visit(this, data);
+            declaration.accept(this, data);
         }
         List<JetConstructor> secondaryConstructors = classBody.getSecondaryConstructors();
         for (JetConstructor constructor : secondaryConstructors) {
-            constructor.visit(this, data);
+            constructor.accept(this, data);
         }
         return null;
     }
@@ -95,7 +95,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitNamespaceBody(JetNamespaceBody body, D data) {
         List<JetDeclaration> declarations = body.getDeclarations();
         for (JetDeclaration declaration : declarations) {
-            declaration.visit(this, data);
+            declaration.accept(this, data);
         }
         return null;
     }
@@ -119,7 +119,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitTypeParameterList(JetTypeParameterList list, D data) {
         List<JetTypeParameter> parameters = list.getParameters();
         for (JetTypeParameter parameter : parameters) {
-            parameter.visit(this, data);
+            parameter.accept(this, data);
         }
         return null;
     }
@@ -133,11 +133,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitEnumEntry(JetEnumEntry enumEntry, D data) {
         List<JetDelegationSpecifier> delegationSpecifiers = enumEntry.getDelegationSpecifiers();
         for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
-            delegationSpecifier.visit(this, data);
+            delegationSpecifier.accept(this, data);
         }
         JetModifierList modifierList = enumEntry.getModifierList();
         if (modifierList != null) {
-            modifierList.visit(this, data);
+            modifierList.accept(this, data);
         }
         return null;
     }
@@ -146,7 +146,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitParameterList(JetParameterList list, D data) {
         List<JetParameter> parameters = list.getParameters();
         for (JetParameter parameter : parameters) {
-            parameter.visit(this, data);
+            parameter.accept(this, data);
         }
         return null;
     }
@@ -160,7 +160,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitDelegationSpecifierList(JetDelegationSpecifierList list, D data) {
         List<JetDelegationSpecifier> delegationSpecifiers = list.getDelegationSpecifiers();
         for (JetDelegationSpecifier delegationSpecifier : delegationSpecifiers) {
-            delegationSpecifier.visit(this, data);
+            delegationSpecifier.accept(this, data);
         }
         return null;
     }
@@ -199,7 +199,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitValueArgumentList(JetValueArgumentList list, D data) {
         List<JetValueArgument> arguments = list.getArguments();
         for (JetValueArgument argument : arguments) {
-            argument.visit(this, data);
+            argument.accept(this, data);
         }
         return null;
     }
@@ -213,7 +213,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitLoopExpression(JetLoopExpression loopExpression, D data) {
         JetExpression body = loopExpression.getBody();
         if (body != null) {
-            body.visit(this, data);
+            body.accept(this, data);
         }
         return null;
     }
@@ -242,7 +242,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitPrefixExpression(JetPrefixExpression expression, D data) {
         JetExpression baseExpression = expression.getBaseExpression();
         if (baseExpression != null) {
-            baseExpression.visit(this, data);
+            baseExpression.accept(this, data);
         }
         return null;
     }
@@ -250,7 +250,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitPostfixExpression(JetPostfixExpression expression, D data) {
         JetExpression baseExpression = expression.getBaseExpression();
-        baseExpression.visit(this, data);
+        baseExpression.accept(this, data);
         return null;
     }
 
@@ -258,17 +258,17 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitUnaryExpression(JetUnaryExpression expression, D data) {
         JetExpression baseExpression = expression.getBaseExpression();
         assert baseExpression != null;
-        baseExpression.visit(this, data);
+        baseExpression.accept(this, data);
         return null;
     }
 
     @Override
     public Void visitBinaryExpression(JetBinaryExpression expression, D data) {
         JetExpression left = expression.getLeft();
-        left.visit(this, data);
+        left.accept(this, data);
         JetExpression right = expression.getRight();
         if (right != null) {
-            right.visit(this, data);
+            right.accept(this, data);
         }
         return super.visitBinaryExpression(expression, data);
     }
@@ -277,7 +277,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitReturnExpression(JetReturnExpression expression, D data) {
         JetExpression returnedExpression = expression.getReturnedExpression();
         if (returnedExpression != null) {
-            returnedExpression.visit(this, data);
+            returnedExpression.accept(this, data);
         }
         return null;
     }
@@ -286,7 +286,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitLabelQualifiedExpression(JetLabelQualifiedExpression expression, D data) {
         JetExpression labeledExpression = expression.getLabeledExpression();
         if (labeledExpression != null) {
-            labeledExpression.visit(this, data);
+            labeledExpression.accept(this, data);
         }
         return null;
     }
@@ -295,7 +295,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitThrowExpression(JetThrowExpression expression, D data) {
         JetExpression thrownExpression = expression.getThrownExpression();
         if (thrownExpression != null) {
-            thrownExpression.visit(this, data);
+            thrownExpression.accept(this, data);
         }
         return null;
     }
@@ -314,15 +314,15 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitIfExpression(JetIfExpression expression, D data) {
         JetExpression condition = expression.getCondition();
         if (condition != null) {
-            condition.visit(this, data);
+            condition.accept(this, data);
         }
         JetExpression then = expression.getThen();
         if (then != null) {
-            then.visit(this, data);
+            then.accept(this, data);
         }
         JetExpression anElse = expression.getElse();
         if (anElse != null) {
-            anElse.visit(this, data);
+            anElse.accept(this, data);
         }
         return null;
     }
@@ -331,11 +331,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitWhenExpression(JetWhenExpression expression, D data) {
         List<JetWhenEntry> entries = expression.getEntries();
         for (JetWhenEntry entry : entries) {
-            entry.visit(this, data);
+            entry.accept(this, data);
         }
         JetExpression subjectExpression = expression.getSubjectExpression();
         if (subjectExpression != null) {
-            subjectExpression.visit(this, data);
+            subjectExpression.accept(this, data);
         }
         return null;
     }
@@ -343,14 +343,14 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitTryExpression(JetTryExpression expression, D data) {
         JetBlockExpression tryBlock = expression.getTryBlock();
-        tryBlock.visit(this, data);
+        tryBlock.accept(this, data);
         List<JetCatchClause> catchClauses = expression.getCatchClauses();
         for (JetCatchClause catchClause : catchClauses) {
-            catchClause.visit(this, data);
+            catchClause.accept(this, data);
         }
         JetFinallySection finallyBlock = expression.getFinallyBlock();
         if (finallyBlock != null) {
-            finallyBlock.visit(this, data);
+            finallyBlock.accept(this, data);
         }
         return null;
     }
@@ -359,11 +359,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitForExpression(JetForExpression expression, D data) {
         JetParameter loopParameter = expression.getLoopParameter();
         if (loopParameter != null) {
-            loopParameter.visit(this, data);
+            loopParameter.accept(this, data);
         }
         JetExpression loopRange = expression.getLoopRange();
         if (loopRange != null) {
-            loopRange.visit(this, data);
+            loopRange.accept(this, data);
         }
         visitLoopExpression(expression, data);
         return null;
@@ -373,7 +373,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitWhileExpression(JetWhileExpression expression, D data) {
         JetExpression condition = expression.getCondition();
         if (condition != null) {
-            condition.visit(this, data);
+            condition.accept(this, data);
         }
         visitLoopExpression(expression, data);
         return null;
@@ -383,7 +383,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitDoWhileExpression(JetDoWhileExpression expression, D data) {
         JetExpression condition = expression.getCondition();
         if (condition != null) {
-            condition.visit(this, data);
+            condition.accept(this, data);
         }
         visitLoopExpression(expression, data);
         return null;
@@ -392,7 +392,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression, D data) {
         JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
-        functionLiteral.visit(this, data);
+        functionLiteral.accept(this, data);
         visitDeclarationWithBody(expression, data);
         return null;
     }
@@ -400,7 +400,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitAnnotatedExpression(JetAnnotatedExpression expression, D data) {
         JetExpression baseExpression = expression.getBaseExpression();
-        baseExpression.visit(this, data);
+        baseExpression.accept(this, data);
         return null;
     }
 
@@ -408,7 +408,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitCallExpression(JetCallExpression expression, D data) {
         JetExpression calleeExpression = expression.getCalleeExpression();
         if (calleeExpression != null) {
-            calleeExpression.visit(this, data);
+            calleeExpression.accept(this, data);
         }
         return null;
     }
@@ -416,10 +416,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitArrayAccessExpression(JetArrayAccessExpression expression, D data) {
         JetExpression arrayExpression = expression.getArrayExpression();
-        arrayExpression.visit(this, data);
+        arrayExpression.accept(this, data);
         List<JetExpression> indexExpressions = expression.getIndexExpressions();
         for (JetExpression indexExpression : indexExpressions) {
-            indexExpression.visit(this, data);
+            indexExpression.accept(this, data);
         }
         return null;
     }
@@ -427,10 +427,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitQualifiedExpression(JetQualifiedExpression expression, D data) {
         JetExpression receiver = expression.getReceiverExpression();
-        receiver.visit(this, data);
+        receiver.accept(this, data);
         JetExpression selector = expression.getSelectorExpression();
         if (selector != null) {
-            selector.visit(this, data);
+            selector.accept(this, data);
         }
         return null;
     }
@@ -462,7 +462,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitObjectLiteralExpression(JetObjectLiteralExpression expression, D data) {
         JetObjectDeclaration objectDeclaration = expression.getObjectDeclaration();
-        objectDeclaration.visit(this, data);
+        objectDeclaration.accept(this, data);
         return null;
     }
 
@@ -475,7 +475,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitBlockExpression(JetBlockExpression expression, D data) {
         List<JetElement> statements = expression.getStatements();
         for (JetElement statement : statements) {
-            statement.visit(this, data);
+            statement.accept(this, data);
         }
         return null;
     }
@@ -484,11 +484,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitCatchSection(JetCatchClause catchClause, D data) {
         JetParameter catchParameter = catchClause.getCatchParameter();
         if (catchParameter != null) {
-            catchParameter.visit(this, data);
+            catchParameter.accept(this, data);
         }
         JetExpression catchBody = catchClause.getCatchBody();
         if (catchBody != null) {
-            catchBody.visit(this, data);
+            catchBody.accept(this, data);
         }
         return null;
     }
@@ -496,7 +496,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitFinallySection(JetFinallySection finallySection, D data) {
         JetBlockExpression finalExpression = finallySection.getFinalExpression();
-        finalExpression.visit(this, data);
+        finalExpression.accept(this, data);
         return null;
     }
 
@@ -504,7 +504,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitTypeArgumentList(JetTypeArgumentList typeArgumentList, D data) {
         List<JetTypeProjection> arguments = typeArgumentList.getArguments();
         for (JetTypeProjection argument : arguments) {
-            argument.visit(this, data);
+            argument.accept(this, data);
         }
         return null;
     }
@@ -512,10 +512,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitThisExpression(JetThisExpression expression, D data) {
         JetReferenceExpression thisReference = expression.getThisReference();
-        thisReference.visit(this, data);
+        thisReference.accept(this, data);
         JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
         if (superTypeQualifier != null) {
-            superTypeQualifier.visit(this, data);
+            superTypeQualifier.accept(this, data);
         }
         visitLabelQualifiedExpression(expression, data);
         return null;
@@ -525,7 +525,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitParenthesizedExpression(JetParenthesizedExpression expression, D data) {
         JetExpression innerExpression = expression.getExpression();
         if (innerExpression != null) {
-            innerExpression.visit(this, data);
+            innerExpression.accept(this, data);
         }
         return null;
     }
@@ -534,7 +534,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitInitializerList(JetInitializerList list, D data) {
         List<JetDelegationSpecifier> initializers = list.getInitializers();
         for (JetDelegationSpecifier initializer : initializers) {
-            initializer.visit(this, data);
+            initializer.accept(this, data);
         }
         return null;
     }
@@ -542,7 +542,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitAnonymousInitializer(JetClassInitializer initializer, D data) {
         JetExpression body = initializer.getBody();
-        body.visit(this, data);
+        body.accept(this, data);
         return null;
     }
 
@@ -556,7 +556,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitTypeConstraintList(JetTypeConstraintList list, D data) {
         List<JetTypeConstraint> constraints = list.getConstraints();
         for (JetTypeConstraint constraint : constraints) {
-            constraint.visit(this, data);
+            constraint.accept(this, data);
         }
         return null;
     }
@@ -565,7 +565,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitTypeConstraint(JetTypeConstraint constraint, D data) {
         JetSimpleNameExpression subjectTypeParameterName = constraint.getSubjectTypeParameterName();
         if (subjectTypeParameterName != null) {
-            subjectTypeParameterName.visit(this, data);
+            subjectTypeParameterName.accept(this, data);
         }
         return null;
     }
@@ -593,10 +593,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, D data) {
         JetExpression left = expression.getLeft();
-        left.visit(this, data);
+        left.accept(this, data);
         JetTypeReference right = expression.getRight();
         if (right != null) {
-            right.visit(this, data);
+            right.accept(this, data);
         }
         return null;
     }
@@ -605,7 +605,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitStringTemplateExpression(JetStringTemplateExpression expression, D data) {
         JetStringTemplateEntry[] entries = expression.getEntries();
         for (JetStringTemplateEntry entry : entries) {
-            entry.visit(this, data);
+            entry.accept(this, data);
         }
         return null;
     }
@@ -629,11 +629,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitWhenEntry(JetWhenEntry jetWhenEntry, D data) {
         JetExpression expression = jetWhenEntry.getExpression();
         if (expression != null) {
-            expression.visit(this, data);
+            expression.accept(this, data);
         }
         JetWhenCondition[] conditions = jetWhenEntry.getConditions();
         for (JetWhenCondition condition : conditions) {
-            condition.visit(this, data);
+            condition.accept(this, data);
         }
         return null;
     }
@@ -641,12 +641,12 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitIsExpression(JetIsExpression expression, D data) {
         JetExpression leftHandSide = expression.getLeftHandSide();
-        leftHandSide.visit(this, data);
+        leftHandSide.accept(this, data);
         JetSimpleNameExpression operationReference = expression.getOperationReference();
-        operationReference.visit(this, data);
+        operationReference.accept(this, data);
         JetPattern pattern = expression.getPattern();
         if (pattern != null) {
-            pattern.visit(this, data);
+            pattern.accept(this, data);
         }
         return null;
     }
@@ -655,7 +655,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitWhenConditionCall(JetWhenConditionCall condition, D data) {
         JetExpression callSuffixExpression = condition.getCallSuffixExpression();
         if (callSuffixExpression != null) {
-            callSuffixExpression.visit(this, data);
+            callSuffixExpression.accept(this, data);
         }
         return null;
     }
@@ -664,7 +664,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitWhenConditionIsPattern(JetWhenConditionIsPattern condition, D data) {
         JetPattern pattern = condition.getPattern();
         if (pattern != null) {
-            pattern.visit(this, data);
+            pattern.accept(this, data);
         }
         return null;
     }
@@ -672,10 +672,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitWhenConditionInRange(JetWhenConditionInRange condition, D data) {
         JetSimpleNameExpression operationReference = condition.getOperationReference();
-        operationReference.visit(this, data);
+        operationReference.accept(this, data);
         JetExpression rangeExpression = condition.getRangeExpression();
         if (rangeExpression != null) {
-            rangeExpression.visit(this, data);
+            rangeExpression.accept(this, data);
         }
         return null;
     }
@@ -694,7 +694,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitExpressionPattern(JetExpressionPattern pattern, D data) {
         JetExpression expression = pattern.getExpression();
         if (expression != null) {
-            expression.visit(this, data);
+            expression.accept(this, data);
         }
         return null;
     }
@@ -703,7 +703,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitTuplePattern(JetTuplePattern pattern, D data) {
         List<JetTuplePatternEntry> entries = pattern.getEntries();
         for (JetTuplePatternEntry entry : entries) {
-            entry.visit(this, data);
+            entry.accept(this, data);
         }
         return null;
     }
@@ -711,10 +711,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     @Override
     public Void visitDecomposerPattern(JetDecomposerPattern pattern, D data) {
         JetTuplePattern argumentList = pattern.getArgumentList();
-        argumentList.visit(this, data);
+        argumentList.accept(this, data);
         JetExpression decomposerExpression = pattern.getDecomposerExpression();
         if (decomposerExpression != null) {
-            decomposerExpression.visit(this, data);
+            decomposerExpression.accept(this, data);
         }
         return null;
     }
@@ -723,11 +723,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitObjectDeclaration(JetObjectDeclaration objectDeclaration, D data) {
         List<JetDeclaration> declarations = objectDeclaration.getDeclarations();
         for (JetDeclaration declaration : declarations) {
-            declaration.visit(this, data);
+            declaration.accept(this, data);
         }
         JetDelegationSpecifierList delegationSpecifierList = objectDeclaration.getDelegationSpecifierList();
         if (delegationSpecifierList != null) {
-            delegationSpecifierList.visit(this, data);
+            delegationSpecifierList.accept(this, data);
         }
         return null;
     }
@@ -736,10 +736,10 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitBindingPattern(JetBindingPattern pattern, D data) {
         JetWhenCondition condition = pattern.getCondition();
         if (condition != null) {
-            condition.visit(this, data);
+            condition.accept(this, data);
         }
         JetProperty variableDeclaration = pattern.getVariableDeclaration();
-        variableDeclaration.visit(this, data);
+        variableDeclaration.accept(this, data);
         return null;
     }
 
@@ -747,7 +747,7 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     public Void visitStringTemplateEntry(JetStringTemplateEntry entry, D data) {
         JetExpression expression = entry.getExpression();
         if (expression != null) {
-            expression.visit(this, data);
+            expression.accept(this, data);
         }
         return null;
     }
@@ -785,11 +785,11 @@ public class JetTreeVisitor<D> extends JetVisitor<Void, D> {
     private Void visitDeclarationWithBody(JetDeclarationWithBody declaration, D data) {
         JetExpression bodyExpression = declaration.getBodyExpression();
         if (bodyExpression != null) {
-            bodyExpression.visit(this, data);
+            bodyExpression.accept(this, data);
         }
         List<JetParameter> valueParameters = declaration.getValueParameters();
         for (JetParameter valueParameter : valueParameters) {
-            valueParameter.visit(this, data);
+            valueParameter.accept(this, data);
         }
         return null;
     }

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

@@ -21,7 +21,7 @@ public class JetTryExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTryExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetTupleExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTupleExpression(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetTuplePattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTuplePattern(this, data);
     }
 

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

@@ -26,7 +26,7 @@ public class JetTupleType extends JetTypeElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTupleType(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetTypeArgumentList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeArgumentList(this, data);
     }
 

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

@@ -21,7 +21,7 @@ public class JetTypeConstraint extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeConstraint(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetTypeConstraintList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeConstraintList(this, data);
     }
 

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

@@ -21,7 +21,7 @@ public class JetTypeParameter extends JetNamedDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeParameter(this, data);
     }
 

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

@@ -24,7 +24,7 @@ public class JetTypeParameterList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeParameterList(this, data);
     }
 }

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

@@ -23,7 +23,7 @@ public class JetTypePattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypePattern(this, data);
     }
 }

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

@@ -33,7 +33,7 @@ public class JetTypeProjection extends JetDeclaration {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeProjection(this, data);
     }
 

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

@@ -23,7 +23,7 @@ public class JetTypeReference extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypeReference(this, data);
     }
 

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

@@ -19,7 +19,7 @@ public class JetTypedef extends JetTypeParameterListOwner {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitTypedef(this, data);
     }
 

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

@@ -28,7 +28,7 @@ public class JetUserType extends JetTypeElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitUserType(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetValueArgument extends JetElement implements ValueArgument {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitArgument(this, data);
     }
 

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

@@ -20,7 +20,7 @@ public class JetValueArgumentList extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitValueArgumentList(this, data);
     }
 

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

@@ -34,7 +34,7 @@ public class JetWhenConditionCall extends JetWhenCondition {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionCall(this, data);
     }
 }

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

@@ -40,7 +40,7 @@ public class JetWhenConditionInRange extends JetWhenCondition {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionInRange(this, data);
     }
 

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

@@ -28,7 +28,7 @@ public class JetWhenConditionIsPattern extends JetWhenCondition {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhenConditionIsPattern(this, data);
     }
 }

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

@@ -28,7 +28,7 @@ public class JetWhenEntry extends JetElement {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhenEntry(this, data);
     }
 

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

@@ -31,7 +31,7 @@ public class JetWhenExpression extends JetExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhenExpression(this, data);
     }
 }

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

@@ -19,7 +19,7 @@ public class JetWhileExpression extends JetLoopExpression {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWhileExpression(this, data);
     }
 

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

@@ -17,7 +17,7 @@ public class JetWildcardPattern extends JetPattern {
     }
 
     @Override
-    public <R, D> R visit(@NotNull JetVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
         return visitor.visitWildcardPattern(this, data);
     }
 }

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

@@ -9,12 +9,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallMaker;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTyperServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -127,7 +129,7 @@ public class BodyResolver {
         final JetScope scopeForConstructor = primaryConstructor == null
                 ? null
                 : getInnerScopeForConstructor(primaryConstructor, descriptor.getScopeForMemberResolution(), true);
-        final ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors); // TODO : flow
+        final ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors); // TODO : flow
 
         final Map<JetTypeReference, JetType> supertypes = Maps.newLinkedHashMap();
         JetVisitorVoid visitor = new JetVisitorVoid() {
@@ -174,7 +176,7 @@ public class BodyResolver {
                 JetTypeReference typeReference = call.getTypeReference();
                 if (typeReference != null) {
                     if (descriptor.getUnsubstitutedPrimaryConstructor() != null) {
-                        JetType supertype = typeInferrer.getCallResolver().resolveCall(
+                        JetType supertype = new CallResolver(context.getSemanticServices(), DataFlowInfo.getEmpty()).resolveCall(
                                 context.getTrace(), scopeForConstructor,
                                 CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE);
                         if (supertype != null) {
@@ -294,7 +296,7 @@ public class BodyResolver {
             ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
             assert primaryConstructor != null;
             final JetScope scopeForConstructor = getInnerScopeForConstructor(primaryConstructor, classDescriptor.getScopeForMemberResolution(), true);
-            ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(createFieldAssignTrackingTrace()); // TODO : flow
+            ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(createFieldAssignTrackingTrace()); // TODO : flow
             for (JetClassInitializer anonymousInitializer : anonymousInitializers) {
                 typeInferrer.getType(scopeForConstructor, anonymousInitializer.getBody(), NO_EXPECTED_TYPE);
             }
@@ -320,7 +322,7 @@ public class BodyResolver {
     private void resolveSecondaryConstructorBody(JetConstructor declaration, final ConstructorDescriptor descriptor, final JetScope declaringScope) {
         final JetScope functionInnerScope = getInnerScopeForConstructor(descriptor, declaringScope, false);
 
-        final ExpressionTyperServices typeInferrerForInitializers = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
+        final CallResolver callResolver = new CallResolver(context.getSemanticServices(), DataFlowInfo.getEmpty()); // TODO: dataFlowInfo
 
         JetClass containingClass = PsiTreeUtil.getParentOfType(declaration, JetClass.class);
         assert containingClass != null : "This must be guaranteed by the parser";
@@ -338,7 +340,7 @@ public class BodyResolver {
                     public void visitDelegationToSuperCallSpecifier(JetDelegatorToSuperCall call) {
                         JetTypeReference typeReference = call.getTypeReference();
                         if (typeReference != null) {
-                            typeInferrerForInitializers.getCallResolver().resolveCall(context.getTrace(), functionInnerScope,
+                            callResolver.resolveCall(context.getTrace(), functionInnerScope,
                                                                                       CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE);
                         }
                     }
@@ -349,7 +351,7 @@ public class BodyResolver {
                         // TODO : check: if a this() call is present, no other initializers are allowed
                         ClassDescriptor classDescriptor = descriptor.getContainingDeclaration();
 
-                        typeInferrerForInitializers.getCallResolver().resolveCall(context.getTrace(),
+                        callResolver.resolveCall(context.getTrace(),
                                 functionInnerScope,
                                 CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE);
 //                                call.getThisReference(),
@@ -384,9 +386,9 @@ public class BodyResolver {
         if (bodyExpression != null) {
             //context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
             //JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(declaration, bodyExpression);
-            ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
+            ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
 
-            typeInferrer.checkFunctionReturnType(functionInnerScope, declaration, descriptor, JetStandardClasses.getUnitType());
+            typeInferrer.checkFunctionReturnType(functionInnerScope, declaration, JetStandardClasses.getUnitType());
         }
     }
 
@@ -522,7 +524,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
-        ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
+        ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(traceForConstructors);
         JetType type = typeInferrer.getType(getPropertyDeclarationInnerScope(scope, propertyDescriptor), initializer, NO_EXPECTED_TYPE);
 
         JetType expectedType = propertyDescriptor.getInType();
@@ -558,12 +560,12 @@ public class BodyResolver {
         JetExpression bodyExpression = function.getBodyExpression();
         if (bodyExpression != null) {
             //JetFlowInformationProvider flowInformationProvider = context.getClassDescriptorResolver().computeFlowData(function.asElement(), bodyExpression);
-            ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace);
+            ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace);
 
             typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptor);
         }
 
-        ExpressionTyperServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace);
+        ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace);
         List<JetParameter> valueParameters = function.getValueParameters();
         for (int i = 0; i < valueParameters.size(); i++) {
             ValueParameterDescriptor valueParameterDescriptor = functionDescriptor.getValueParameters().get(i);

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

@@ -10,7 +10,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTyperServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 
 import java.util.List;
 import java.util.Map;
@@ -24,7 +24,7 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
  */
 public class ControlFlowAnalyzer {
     private TopDownAnalysisContext context;
-    private ExpressionTyperServices typeInferrer;
+    private ExpressionTypingServices typeInferrer;
 
     public ControlFlowAnalyzer(TopDownAnalysisContext context) {
         this.context = context;

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

@@ -15,7 +15,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
 import org.jetbrains.jet.lang.types.*;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTyperServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.*;
@@ -218,7 +218,7 @@ public class TypeHierarchyResolver {
             if (importDirective.isAllUnder()) {
                 JetExpression importedReference = importDirective.getImportedReference();
                 if (importedReference != null) {
-                    ExpressionTyperServices typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace());
+                    ExpressionTypingServices typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace());
                     JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference);
                     if (type != null) {
                         namespaceScope.importScope(type.getMemberScope());

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/AutoCastUtils.java

@@ -82,7 +82,6 @@ public class AutoCastUtils {
     public static JetType castExpression(@NotNull JetExpression expression, @NotNull JetType expectedType, @NotNull DataFlowInfo dataFlowInfo, @NotNull BindingTrace trace) {
         JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
         VariableDescriptor variableDescriptor = getVariableDescriptorFromSimpleName(trace.getBindingContext(), expression);
-//        boolean appropriateTypeFound = false;
         if (variableDescriptor != null) {
             List<JetType> possibleTypes = Lists.newArrayList(dataFlowInfo.getPossibleTypesForVariable(variableDescriptor));
             Collections.reverse(possibleTypes);
@@ -97,24 +96,12 @@ public class AutoCastUtils {
                     return possibleType;
                 }
             }
-//            if (!appropriateTypeFound) {
-//                JetType notnullType = dataFlowInfo.getOutType(variableDescriptor);
-//                if (notnullType != null && typeChecker.isSubtypeOf(notnullType, expectedType)) {
-//                    appropriateTypeFound = true;
-//                }
-//            }
         }
         return null;
     }
 
     @Nullable
     public static VariableDescriptor getVariableDescriptorFromSimpleName(@NotNull BindingContext bindingContext, @NotNull JetExpression expression) {
-//        if (expression instanceof JetBinaryExpressionWithTypeRHS) {
-//            JetBinaryExpressionWithTypeRHS expression = (JetBinaryExpressionWithTypeRHS) expression;
-//            if (expression.getOperationSign().getReferencedNameElementType() == JetTokens.COLON) {
-//                return getVariableDescriptorFromSimpleName(bindingContext, expression.getLeft());
-//            }
-//        }
         JetExpression receiver = JetPsiUtil.deparenthesize(expression);
         VariableDescriptor variableDescriptor = null;
         if (receiver instanceof JetSimpleNameExpression) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java

@@ -15,7 +15,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTyperServices;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
 import org.jetbrains.jet.lang.types.inference.ConstraintSystem;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -384,7 +384,7 @@ public class CallResolver {
                         for (JetExpression expression : valueArgument.getArgumentExpressions()) {
 //                            JetExpression expression = valueArgument.getArgumentExpression();
                             // TODO : more attempts, with different expected types
-                            ExpressionTyperServices temporaryServices = new ExpressionTyperServices(semanticServices, temporaryTrace);
+                            ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, temporaryTrace);
                             JetType type = temporaryServices.getType(scope, expression, NO_EXPECTED_TYPE);
                             if (type != null) {
                                 constraintSystem.addSubtypingConstraint(type, valueParameterDescriptor.getOutType());
@@ -509,7 +509,7 @@ public class CallResolver {
     }
 
     private void checkTypesWithNoCallee(BindingTrace trace, JetScope scope, Call call) {
-        ExpressionTyperServices typeInferrerServices = new ExpressionTyperServices(semanticServices, trace);
+        ExpressionTypingServices typeInferrerServices = new ExpressionTypingServices(semanticServices, trace);
         for (ValueArgument valueArgument : call.getValueArguments()) {
             JetExpression argumentExpression = valueArgument.getArgumentExpression();
             if (argumentExpression != null) {
@@ -602,7 +602,7 @@ public class CallResolver {
 
             List<JetExpression> argumentExpressions = resolvedArgument.getArgumentExpressions();
             for (JetExpression argumentExpression : argumentExpressions) {
-                ExpressionTyperServices temporaryServices = new ExpressionTyperServices(semanticServices, candidateCall.getTrace());
+                ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, candidateCall.getTrace());
                 JetType type = temporaryServices.getType(scope, argumentExpression, parameterType);
                 if (type == null) {
                     candidateCall.argumentHasNoType();

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

@@ -0,0 +1,779 @@
+package org.jetbrains.jet.lang.types.expressions;
+
+import com.google.common.collect.Lists;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.calls.CallMaker;
+import org.jetbrains.jet.lang.resolve.calls.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
+import org.jetbrains.jet.lang.resolve.constants.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+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.types.*;
+import org.jetbrains.jet.lexer.JetTokens;
+
+import java.util.*;
+
+import static org.jetbrains.jet.lang.diagnostics.Errors.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.*;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
+import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.*;
+
+/**
+* @author abreslav
+*/
+public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
+    protected BasicExpressionTypingVisitor(@NotNull ExpressionTypingInternals facade) {
+        super(facade);
+    }
+
+    @Override
+    public JetType visitSimpleNameExpression(JetSimpleNameExpression expression, ExpressionTypingContext context) {
+        // TODO : other members
+        // TODO : type substitutions???
+        String referencedName = expression.getReferencedName();
+        if (expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER
+                && referencedName != null) {
+            PropertyDescriptor property = context.scope.getPropertyByFieldReference(referencedName);
+            if (property == null) {
+                context.trace.report(UNRESOLVED_REFERENCE.on(expression));
+            }
+            else {
+                context.trace.record(REFERENCE_TARGET, expression, property);
+                return checkType(property.getOutType(), expression, context);
+            }
+        }
+        else {
+            return getSelectorReturnType(NO_RECEIVER, null, expression, context); // TODO : Extensions to this
+        }
+        return null;
+    }
+
+    private JetType lookupNamespaceOrClassObject(JetSimpleNameExpression expression, String referencedName, ExpressionTypingContext context) {
+        ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
+        if (classifier != null) {
+            JetType classObjectType = classifier.getClassObjectType();
+            JetType result = null;
+            if (classObjectType != null) {
+                if (context.namespacesAllowed || classifier.isClassObjectAValue()) {
+                    result = classObjectType;
+                }
+                else {
+                    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 checkType(result, expression, context);
+            }
+        }
+        JetType[] result = new JetType[1];
+        TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace);
+        if (furtherNameLookup(expression, referencedName, result, context.replaceBindingTrace(temporaryTrace))) {
+            temporaryTrace.commit();
+            return checkType(result[0], expression, context);
+        }
+        // To report NO_CLASS_OBJECT when no namespace found
+        if (classifier != null) {
+            context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
+            context.trace.record(REFERENCE_TARGET, expression, classifier);
+            return ErrorUtils.createErrorType("No class object in " + expression.getReferencedName());
+        }
+        temporaryTrace.commit();
+        return result[0];
+    }
+
+    protected boolean furtherNameLookup(@NotNull JetSimpleNameExpression expression, @NotNull String referencedName, @NotNull JetType[] result, ExpressionTypingContext context) {
+        if (context.namespacesAllowed) {
+            result[0] = lookupNamespaceType(expression, referencedName, context);
+            return result[0] != null;
+        }
+        NamespaceType namespaceType = lookupNamespaceType(expression, referencedName, context);
+        if (namespaceType != null) {
+            context.trace.report(EXPRESSION_EXPECTED_NAMESPACE_FOUND.on(expression));
+            result[0] = ErrorUtils.createErrorType("Type for " + referencedName);
+        }
+        return false;
+    }
+
+    @Nullable
+    protected NamespaceType lookupNamespaceType(@NotNull JetSimpleNameExpression expression, @NotNull String referencedName, ExpressionTypingContext context) {
+        NamespaceDescriptor namespace = context.scope.getNamespace(referencedName);
+        if (namespace == null) {
+            return null;
+        }
+        context.trace.record(REFERENCE_TARGET, expression, namespace);
+        return namespace.getNamespaceType();
+    }
+
+    @Override
+    public JetType visitParenthesizedExpression(JetParenthesizedExpression expression, ExpressionTypingContext context) {
+        JetExpression innerExpression = expression.getExpression();
+        if (innerExpression == null) {
+            return null;
+        }
+        return checkType(facade.getType(innerExpression, context.replaceScope(context.scope)), expression, context);
+    }
+
+    @Override
+    public JetType visitConstantExpression(JetConstantExpression expression, ExpressionTypingContext context) {
+        ASTNode node = expression.getNode();
+        IElementType elementType = node.getElementType();
+        String text = node.getText();
+        JetStandardLibrary standardLibrary = context.semanticServices.getStandardLibrary();
+        CompileTimeConstantResolver compileTimeConstantResolver = context.getCompileTimeConstantResolver();
+
+        CompileTimeConstant<?> value;
+        if (elementType == JetNodeTypes.INTEGER_CONSTANT) {
+            value = compileTimeConstantResolver.getIntegerValue(text, context.expectedType);
+        }
+        else if (elementType == JetNodeTypes.FLOAT_CONSTANT) {
+            value = compileTimeConstantResolver.getFloatValue(text, context.expectedType);
+        }
+        else if (elementType == JetNodeTypes.BOOLEAN_CONSTANT) {
+            value = compileTimeConstantResolver.getBooleanValue(text, context.expectedType);
+        }
+        else if (elementType == JetNodeTypes.CHARACTER_CONSTANT) {
+            value = compileTimeConstantResolver.getCharValue(text, context.expectedType);
+        }
+        else if (elementType == JetNodeTypes.RAW_STRING_CONSTANT) {
+            value = compileTimeConstantResolver.getRawStringValue(text, context.expectedType);
+        }
+        else if (elementType == JetNodeTypes.NULL) {
+            value = compileTimeConstantResolver.getNullValue(context.expectedType);
+        }
+        else {
+            throw new IllegalArgumentException("Unsupported constant: " + expression);
+        }
+        if (value instanceof ErrorValue) {
+            ErrorValue errorValue = (ErrorValue) value;
+            context.trace.report(ERROR_COMPILE_TIME_VALUE.on(node, errorValue.getMessage()));
+            return getDefaultType(context.semanticServices, elementType);
+        }
+        else {
+            context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, value);
+            return checkType(value.getType(standardLibrary), expression, context);
+        }
+    }
+
+    @Override
+    public JetType visitBinaryWithTypeRHSExpression(JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context) {
+        JetTypeReference right = expression.getRight();
+        JetType result = null;
+        if (right != null) {
+            JetType targetType = context.getTypeResolver().resolveType(context.scope, right);
+
+            if (isTypeFlexible(expression.getLeft())) {
+                TemporaryBindingTrace temporaryTraceWithExpectedType = TemporaryBindingTrace.create(context.trace);
+                boolean success = checkBinaryWithTypeRHS(expression, context, targetType, targetType, temporaryTraceWithExpectedType);
+                if (success) {
+                    temporaryTraceWithExpectedType.commit();
+                }
+                else {
+                    TemporaryBindingTrace temporaryTraceWithoutExpectedType = TemporaryBindingTrace.create(context.trace);
+                    checkBinaryWithTypeRHS(expression, context, targetType, NO_EXPECTED_TYPE, temporaryTraceWithoutExpectedType);
+                    temporaryTraceWithoutExpectedType.commit();
+                }
+            }
+            else {
+                TemporaryBindingTrace temporaryTraceWithoutExpectedType = TemporaryBindingTrace.create(context.trace);
+                checkBinaryWithTypeRHS(expression, context, targetType, NO_EXPECTED_TYPE, temporaryTraceWithoutExpectedType);
+                temporaryTraceWithoutExpectedType.commit();
+            }
+
+            IElementType operationType = expression.getOperationSign().getReferencedNameElementType();
+            result = operationType == JetTokens.AS_SAFE ? TypeUtils.makeNullable(targetType) : targetType;
+        }
+        else {
+            facade.getType(expression.getLeft(), context.replaceExpectedType(NO_EXPECTED_TYPE));
+        }
+        return checkType(result, expression, context);
+    }
+
+    private boolean checkBinaryWithTypeRHS(JetBinaryExpressionWithTypeRHS expression, ExpressionTypingContext context, @NotNull JetType targetType, @NotNull JetType expectedType, TemporaryBindingTrace temporaryTrace) {
+        ExpressionTypingContext newContext = context.replaceExpectedType(expectedType).replaceBindingTrace(temporaryTrace);
+
+        JetType actualType = facade.getType(expression.getLeft(), newContext);
+        if (actualType == null) return false;
+
+        JetSimpleNameExpression operationSign = expression.getOperationSign();
+        IElementType operationType = operationSign.getReferencedNameElementType();
+        if (operationType == JetTokens.COLON) {
+            if (targetType != NO_EXPECTED_TYPE && !context.semanticServices.getTypeChecker().isSubtypeOf(actualType, targetType)) {
+                context.trace.report(TYPE_MISMATCH.on(expression.getLeft(), targetType, actualType));
+                return false;
+            }
+            return true;
+        }
+        else if (operationType == JetTokens.AS_KEYWORD || operationType == JetTokens.AS_SAFE) {
+            checkForCastImpossibility(expression, actualType, targetType, context);
+            return true;
+        }
+        else {
+            context.trace.report(UNSUPPORTED.on(operationSign, "binary operation with type RHS"));
+            return false;
+        }
+    }
+
+    private void checkForCastImpossibility(JetBinaryExpressionWithTypeRHS expression, JetType actualType, JetType targetType, ExpressionTypingContext context) {
+        if (actualType == null || targetType == NO_EXPECTED_TYPE) return;
+
+        JetTypeChecker typeChecker = context.semanticServices.getTypeChecker();
+        if (!typeChecker.isSubtypeOf(targetType, actualType)) {
+            if (typeChecker.isSubtypeOf(actualType, targetType)) {
+                context.trace.report(USELESS_CAST_STATIC_ASSERT_IS_FINE.on(expression, expression.getOperationSign()));
+            }
+            else {
+                // See JET-58 Make 'as never succeeds' a warning, or even never check for Java (external) types
+                context.trace.report(CAST_NEVER_SUCCEEDS.on(expression.getOperationSign()));
+            }
+        }
+        else {
+            if (typeChecker.isSubtypeOf(actualType, targetType)) {
+                context.trace.report(USELESS_CAST.on(expression, expression.getOperationSign()));
+            }
+        }
+    }
+
+    @Override
+    public JetType visitTupleExpression(JetTupleExpression expression, ExpressionTypingContext context) {
+        List<JetExpression> entries = expression.getEntries();
+        List<JetType> types = new ArrayList<JetType>();
+        for (JetExpression entry : entries) {
+            types.add(context.getServices().safeGetType(context.scope, entry, NO_EXPECTED_TYPE)); // TODO
+        }
+        if (context.expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isTupleType(context.expectedType)) {
+            List<JetType> enrichedTypes = checkArgumentTypes(types, entries, context.expectedType.getArguments(), context);
+            if (enrichedTypes != types) {
+                return JetStandardClasses.getTupleType(enrichedTypes);
+            }
+        }
+        // TODO : labels
+        return checkType(JetStandardClasses.getTupleType(types), expression, context);
+    }
+
+    @NotNull
+    private List<JetType> checkArgumentTypes(@NotNull List<JetType> argumentTypes, @NotNull List<JetExpression> arguments, @NotNull List<TypeProjection> expectedArgumentTypes, @NotNull ExpressionTypingContext context) {
+        if (arguments.size() == 0 || argumentTypes.size() != arguments.size() || expectedArgumentTypes.size() != arguments.size()) {
+            return argumentTypes;
+        }
+        List<JetType> result = Lists.newArrayListWithCapacity(arguments.size());
+        for (int i = 0, argumentTypesSize = argumentTypes.size(); i < argumentTypesSize; i++) {
+            result.add(checkType(argumentTypes.get(i), arguments.get(i), context.replaceExpectedType(expectedArgumentTypes.get(i).getType())));
+        }
+        return result;
+    }
+
+    @Override
+    public JetType visitThisExpression(JetThisExpression expression, ExpressionTypingContext context) {
+        JetType result = null;
+        ReceiverDescriptor thisReceiver = null;
+        String labelName = expression.getLabelName();
+        if (labelName != null) {
+            thisReceiver = context.labelResolver.resolveThisLabel(expression, context, thisReceiver, labelName);
+        }
+        else {
+            thisReceiver = context.scope.getImplicitReceiver();
+
+            DeclarationDescriptor declarationDescriptorForUnqualifiedThis = context.scope.getDeclarationDescriptorForUnqualifiedThis();
+            if (declarationDescriptorForUnqualifiedThis != null) {
+                context.trace.record(REFERENCE_TARGET, expression.getThisReference(), declarationDescriptorForUnqualifiedThis);
+            }
+        }
+
+        if (thisReceiver != null) {
+            if (!thisReceiver.exists()) {
+                context.trace.report(NO_THIS.on(expression));
+            }
+            else {
+                JetTypeReference superTypeQualifier = expression.getSuperTypeQualifier();
+                if (superTypeQualifier != null) {
+                    JetTypeElement superTypeElement = superTypeQualifier.getTypeElement();
+                    // Errors are reported by the parser
+                    if (superTypeElement instanceof JetUserType) {
+                        JetUserType typeElement = (JetUserType) superTypeElement;
+
+                        ClassifierDescriptor classifierCandidate = context.getTypeResolver().resolveClass(context.scope, typeElement);
+                        if (classifierCandidate instanceof ClassDescriptor) {
+                            ClassDescriptor superclass = (ClassDescriptor) classifierCandidate;
+
+                            JetType thisType = thisReceiver.getType();
+                            Collection<? extends JetType> supertypes = thisType.getConstructor().getSupertypes();
+                            TypeSubstitutor substitutor = TypeSubstitutor.create(thisType);
+                            for (JetType declaredSupertype : supertypes) {
+                                if (declaredSupertype.getConstructor().equals(superclass.getTypeConstructor())) {
+                                    result = substitutor.safeSubstitute(declaredSupertype, Variance.INVARIANT);
+                                    break;
+                                }
+                            }
+                            if (result == null) {
+                                context.trace.report(NOT_A_SUPERTYPE.on(superTypeElement));
+                            }
+                        }
+                    }
+                }
+                else {
+                    result = thisReceiver.getType();
+                }
+                if (result != null) {
+                    context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getThisReference(), result);
+                }
+            }
+        }
+        return checkType(result, expression, context);
+    }
+
+    @Override
+    public JetType visitBlockExpression(JetBlockExpression expression, ExpressionTypingContext context) {
+        return context.getServices().getBlockReturnedType(context.scope, expression, CoercionStrategy.NO_COERCION, context);
+    }
+
+    @Override
+    public JetType visitHashQualifiedExpression(JetHashQualifiedExpression expression, ExpressionTypingContext context) {
+        context.trace.report(UNSUPPORTED.on(expression, getClass().getCanonicalName()));
+        return null;
+    }
+
+    @Override
+    public JetType visitQualifiedExpression(JetQualifiedExpression expression, ExpressionTypingContext contextWithExpectedType) {
+        ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
+        // TODO : functions as values
+        JetExpression selectorExpression = expression.getSelectorExpression();
+        JetExpression receiverExpression = expression.getReceiverExpression();
+        JetType receiverType = facade.getType(receiverExpression,
+                                              context
+                                                      .replaceExpectedType(NO_EXPECTED_TYPE)
+                                                      .replaceExpectedReturnType(NO_EXPECTED_TYPE)
+                                                      .replaceNamespacesAllowed(true));
+        if (selectorExpression == null) return null;
+        if (receiverType == null) receiverType = ErrorUtils.createErrorType("Type for " + expression.getText());
+
+        if (selectorExpression instanceof JetSimpleNameExpression) {
+            propagateConstantValues(expression, context, (JetSimpleNameExpression) selectorExpression);
+        }
+
+        JetType selectorReturnType = getSelectorReturnType(new ExpressionReceiver(receiverExpression, receiverType), expression.getOperationTokenNode(), selectorExpression, context);
+
+        //TODO move further
+        if (expression.getOperationSign() == JetTokens.SAFE_ACCESS) {
+            if (selectorReturnType != null && !selectorReturnType.isNullable() && !JetStandardClasses.isUnit(selectorReturnType)) {
+                selectorReturnType = TypeUtils.makeNullable(selectorReturnType);
+            }
+        }
+
+        JetType result;
+        if (expression.getOperationSign() == JetTokens.QUEST) {
+            if (selectorReturnType != null && !isBoolean(context.semanticServices, selectorReturnType)) {
+                // TODO : more comprehensible error message
+                context.trace.report(TYPE_MISMATCH.on(selectorExpression, context.semanticServices.getStandardLibrary().getBooleanType(), selectorReturnType));
+            }
+            result = TypeUtils.makeNullable(receiverType);
+        }
+        else {
+            result = selectorReturnType;
+        }
+        // TODO : this is suspicious: remove this code?
+        if (result != null) {
+            context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, result);
+        }
+        return checkType(result, expression, contextWithExpectedType);
+    }
+
+    private void propagateConstantValues(JetQualifiedExpression expression, ExpressionTypingContext context, JetSimpleNameExpression selectorExpression) {
+        JetExpression receiverExpression = expression.getReceiverExpression();
+        CompileTimeConstant<?> receiverValue = context.trace.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, receiverExpression);
+        CompileTimeConstant<?> wholeExpressionValue = context.trace.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, expression);
+        if (wholeExpressionValue == null && receiverValue != null && !(receiverValue instanceof ErrorValue) && receiverValue.getValue() instanceof Number) {
+            Number value = (Number) receiverValue.getValue();
+            String referencedName = selectorExpression.getReferencedName();
+            if (OperatorConventions.NUMBER_CONVERSIONS.contains(referencedName)) {
+                if ("dbl".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new DoubleValue(value.doubleValue()));
+                }
+                else if ("flt".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new FloatValue(value.floatValue()));
+                }
+                else if ("lng".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new LongValue(value.longValue()));
+                }
+                else if ("sht".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new ShortValue(value.shortValue()));
+                }
+                else if ("byt".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new ByteValue(value.byteValue()));
+                }
+                else if ("int".equals(referencedName)) {
+                    context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new IntValue(value.intValue()));
+                }
+            }
+        }
+    }
+
+    @Nullable
+    public JetType getSelectorReturnType(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context) {
+        if (selectorExpression instanceof JetCallExpression) {
+            JetCallExpression callExpression = (JetCallExpression) selectorExpression;
+            return context.resolveCall(receiver, callOperationNode, callExpression);
+        }
+        else if (selectorExpression instanceof JetSimpleNameExpression) {
+            JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) selectorExpression;
+
+            TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace);
+            VariableDescriptor variableDescriptor = context.replaceBindingTrace(temporaryTrace).resolveSimpleProperty(receiver, callOperationNode, nameExpression);
+            if (variableDescriptor != null) {
+                temporaryTrace.commit();
+                return checkType(variableDescriptor.getOutType(), nameExpression, context);
+            }
+            ExpressionTypingContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context;
+            JetType jetType = lookupNamespaceOrClassObject(nameExpression, nameExpression.getReferencedName(), newContext);
+            if (jetType == null) {
+                context.trace.report(UNRESOLVED_REFERENCE.on(nameExpression));
+            }
+            return checkType(jetType, nameExpression, context);
+        }
+        else if (selectorExpression instanceof JetQualifiedExpression) {
+            JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression;
+            JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression();
+            JetType newReceiverType = getSelectorReturnType(receiver, callOperationNode, newReceiverExpression, context.replaceExpectedType(NO_EXPECTED_TYPE));
+            JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression();
+            if (newReceiverType != null && newSelectorExpression != null) {
+                return getSelectorReturnType(new ExpressionReceiver(newReceiverExpression, newReceiverType), qualifiedExpression.getOperationTokenNode(), newSelectorExpression, context);
+            }
+        }
+        else {
+            // TODO : not a simple name -> resolve in scope, expect property type or a function type
+            context.trace.report(UNSUPPORTED.on(selectorExpression, "getSelectorReturnType"));
+        }
+        return null;
+    }
+
+    @Override
+    public JetType visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) {
+        JetType expressionType = context.resolveCall(NO_RECEIVER, null, expression);
+        return checkType(expressionType, expression, context);
+    }
+
+    @Override
+    public JetType visitUnaryExpression(JetUnaryExpression expression, ExpressionTypingContext context) {
+        JetExpression baseExpression = expression.getBaseExpression();
+        if (baseExpression == null) return null;
+        JetSimpleNameExpression operationSign = expression.getOperationSign();
+        if (JetTokens.LABELS.contains(operationSign.getReferencedNameElementType())) {
+            String referencedName = operationSign.getReferencedName();
+            referencedName = referencedName == null ? " <?>" : referencedName;
+            context.labelResolver.enterLabeledElement(referencedName.substring(1), baseExpression);
+            // TODO : Some processing for the label?
+            JetType type = checkType(facade.getType(baseExpression, context.replaceExpectedReturnType(context.expectedType)), expression, context);
+            context.labelResolver.exitLabeledElement(baseExpression);
+            return type;
+        }
+        IElementType operationType = operationSign.getReferencedNameElementType();
+        String name = OperatorConventions.UNARY_OPERATION_NAMES.get(operationType);
+        if (name == null) {
+            context.trace.report(UNSUPPORTED.on(operationSign, "visitUnaryExpression"));
+            return null;
+        }
+        ExpressionReceiver receiver = getExpressionReceiver(facade, baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(context.scope));
+        if (receiver == null) return null;
+
+        FunctionDescriptor functionDescriptor = context.resolveCallWithGivenName(
+                CallMaker.makeCall(receiver, expression),
+                expression.getOperationSign(),
+                name,
+                receiver);
+
+        if (functionDescriptor == null) return null;
+        JetType returnType = functionDescriptor.getReturnType();
+        JetType result;
+        if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) {
+            if (context.semanticServices.getTypeChecker().isSubtypeOf(returnType, JetStandardClasses.getUnitType())) {
+                result = JetStandardClasses.getUnitType();
+            }
+            else {
+                JetType receiverType = receiver.getType();
+                if (!context.semanticServices.getTypeChecker().isSubtypeOf(returnType, receiverType)) {
+                    context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name, receiverType, returnType));
+                }
+                else {
+                    context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression);
+                }
+                // TODO : Maybe returnType?
+                result = receiverType;
+            }
+        }
+        else {
+            result = returnType;
+        }
+
+        return checkType(result, expression, context);
+    }
+
+    @Override
+    public JetType visitBinaryExpression(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
+        ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
+        JetSimpleNameExpression operationSign = expression.getOperationReference();
+
+        JetExpression left = expression.getLeft();
+        JetExpression right = expression.getRight();
+
+        JetType result = null;
+        IElementType operationType = operationSign.getReferencedNameElementType();
+        if (operationType == JetTokens.IDENTIFIER) {
+            String referencedName = operationSign.getReferencedName();
+            if (referencedName != null) {
+                result = getTypeForBinaryCall(context.scope, referencedName, context, expression);
+            }
+        }
+        else if (OperatorConventions.BINARY_OPERATION_NAMES.containsKey(operationType)) {
+            result = getTypeForBinaryCall(context.scope, OperatorConventions.BINARY_OPERATION_NAMES.get(operationType), context, expression);
+        }
+        else if (operationType == JetTokens.EQ) {
+            result = visitAssignment(expression, contextWithExpectedType);
+        }
+        else if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
+            result = visitAssignmentOperation(expression, contextWithExpectedType);
+        }
+        else if (OperatorConventions.COMPARISON_OPERATIONS.contains(operationType)) {
+            JetType compareToReturnType = getTypeForBinaryCall(context.scope, "compareTo", context, expression);
+            if (compareToReturnType != null) {
+                TypeConstructor constructor = compareToReturnType.getConstructor();
+                JetStandardLibrary standardLibrary = context.semanticServices.getStandardLibrary();
+                TypeConstructor intTypeConstructor = standardLibrary.getInt().getTypeConstructor();
+                if (constructor.equals(intTypeConstructor)) {
+                    result = standardLibrary.getBooleanType();
+                } else {
+                    context.trace.report(COMPARE_TO_TYPE_MISMATCH.on(operationSign, compareToReturnType));
+                }
+            }
+        }
+        else if (OperatorConventions.EQUALS_OPERATIONS.contains(operationType)) {
+            String name = "equals";
+            if (right != null) {
+                ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope));
+                OverloadResolutionResults<FunctionDescriptor> resolutionResults = context.resolveExactSignature(
+                        receiver, "equals",
+                        Collections.singletonList(JetStandardClasses.getNullableAnyType()));
+                if (resolutionResults.isSuccess()) {
+                    FunctionDescriptor equals = resolutionResults.getResult().getResultingDescriptor();
+                    context.trace.record(REFERENCE_TARGET, operationSign, equals);
+                    if (ensureBooleanResult(operationSign, name, equals.getReturnType(), context)) {
+                        ensureNonemptyIntersectionOfOperandTypes(expression, context);
+                    }
+                }
+                else {
+                    if (resolutionResults.isAmbiguity()) {
+                        context.trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(operationSign, resolutionResults.getResults()));
+                    }
+                    else {
+                        context.trace.report(EQUALS_MISSING.on(operationSign));
+                    }
+                }
+            }
+            result = context.semanticServices.getStandardLibrary().getBooleanType();
+        }
+        else if (operationType == JetTokens.EQEQEQ || operationType == JetTokens.EXCLEQEQEQ) {
+            ensureNonemptyIntersectionOfOperandTypes(expression, context);
+
+            // TODO : Check comparison pointlessness
+            result = context.semanticServices.getStandardLibrary().getBooleanType();
+        }
+        else if (OperatorConventions.IN_OPERATIONS.contains(operationType)) {
+            if (right == null) {
+                result = ErrorUtils.createErrorType("No right argument"); // TODO
+                return null;
+            }
+            checkInExpression(expression, expression.getOperationReference(), expression.getLeft(), expression.getRight(), context);
+            result = context.semanticServices.getStandardLibrary().getBooleanType();
+        }
+        else if (operationType == JetTokens.ANDAND || operationType == JetTokens.OROR) {
+            JetType leftType = facade.getType(left, context.replaceScope(context.scope));
+            WritableScopeImpl leftScope = newWritableScopeImpl(context).setDebugName("Left scope of && or ||");
+            DataFlowInfo flowInfoLeft = extractDataFlowInfoFromCondition(left, operationType == JetTokens.ANDAND, leftScope, context);  // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition
+            WritableScopeImpl rightScope = operationType == JetTokens.ANDAND ? leftScope : newWritableScopeImpl(context).setDebugName("Right scope of && or ||");
+            JetType rightType = right == null ? null : facade.getType(right, context.replaceDataFlowInfo(flowInfoLeft).replaceScope(rightScope));
+            if (leftType != null && !isBoolean(context.semanticServices, leftType)) {
+                context.trace.report(TYPE_MISMATCH.on(left, context.semanticServices.getStandardLibrary().getBooleanType(), leftType));
+            }
+            if (rightType != null && !isBoolean(context.semanticServices, rightType)) {
+                context.trace.report(TYPE_MISMATCH.on(right, context.semanticServices.getStandardLibrary().getBooleanType(), rightType));
+            }
+            result = context.semanticServices.getStandardLibrary().getBooleanType();
+        }
+        else if (operationType == JetTokens.ELVIS) {
+            JetType leftType = facade.getType(left, context.replaceScope(context.scope));
+            JetType rightType = right == null ? null : facade.getType(right, contextWithExpectedType.replaceScope(context.scope));
+            if (leftType != null) {
+                if (!leftType.isNullable()) {
+                    context.trace.report(USELESS_ELVIS.on(expression, left, leftType));
+                }
+                if (rightType != null) {
+                    checkType(TypeUtils.makeNullableAsSpecified(leftType, rightType.isNullable()), left, contextWithExpectedType);
+                    return TypeUtils.makeNullableAsSpecified(context.semanticServices.getTypeChecker().commonSupertype(leftType, rightType), rightType.isNullable());
+                }
+            }
+        }
+        else {
+            context.trace.report(UNSUPPORTED.on(operationSign, "Unknown operation"));
+        }
+        return checkType(result, expression, contextWithExpectedType);
+    }
+
+    public void checkInExpression(JetElement callElement, @NotNull JetSimpleNameExpression operationSign, @NotNull JetExpression left, @NotNull JetExpression right, ExpressionTypingContext context) {
+        String name = "contains";
+        ExpressionReceiver receiver = safeGetExpressionReceiver(facade, right, context.replaceExpectedType(NO_EXPECTED_TYPE));
+        FunctionDescriptor functionDescriptor = context.resolveCallWithGivenName(
+                CallMaker.makeCallWithExpressions(callElement, receiver, null, operationSign, Collections.singletonList(left)),
+                operationSign,
+                name, receiver);
+        JetType containsType = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
+        ensureBooleanResult(operationSign, name, containsType, context);
+    }
+
+    private void ensureNonemptyIntersectionOfOperandTypes(JetBinaryExpression expression, ExpressionTypingContext context) {
+        JetSimpleNameExpression operationSign = expression.getOperationReference();
+        JetExpression left = expression.getLeft();
+        JetExpression right = expression.getRight();
+
+        // TODO : duplicated effort for == and !=
+        JetType leftType = facade.getType(left, context.replaceScope(context.scope));
+        if (leftType != null && right != null) {
+            JetType rightType = facade.getType(right, context.replaceScope(context.scope));
+
+            if (rightType != null) {
+                JetType intersect = TypeUtils.intersect(context.semanticServices.getTypeChecker(), new HashSet<JetType>(Arrays.asList(leftType, rightType)));
+                if (intersect == null) {
+                    context.trace.report(EQUALITY_NOT_APPLICABLE.on(expression, operationSign, leftType, rightType));
+                }
+            }
+        }
+    }
+
+    protected JetType visitAssignmentOperation(JetBinaryExpression expression, ExpressionTypingContext context) {
+        return assignmentIsNotAnExpressionError(expression, context);
+    }
+
+    protected JetType visitAssignment(JetBinaryExpression expression, ExpressionTypingContext context) {
+        return assignmentIsNotAnExpressionError(expression, context);
+    }
+
+    private JetType assignmentIsNotAnExpressionError(JetBinaryExpression expression, ExpressionTypingContext context) {
+        context.trace.report(ASSIGNMENT_IN_EXPRESSION_CONTEXT.on(expression));
+        return null;
+    }
+
+    @Override
+    public JetType visitArrayAccessExpression(JetArrayAccessExpression expression, ExpressionTypingContext contextWithExpectedType) {
+        ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
+        JetExpression arrayExpression = expression.getArrayExpression();
+        ExpressionReceiver receiver = getExpressionReceiver(facade, arrayExpression, context.replaceScope(context.scope));
+
+        if (receiver != null) {
+            FunctionDescriptor functionDescriptor = context.resolveCallWithGivenName(
+                    CallMaker.makeCallWithExpressions(expression, receiver, null, expression, expression.getIndexExpressions()),
+                    expression,
+                    "get",
+                    receiver);
+            if (functionDescriptor != null) {
+                return checkType(functionDescriptor.getReturnType(), expression, contextWithExpectedType);
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    protected JetType getTypeForBinaryCall(JetScope scope, String name, ExpressionTypingContext context, JetBinaryExpression binaryExpression) {
+        ExpressionReceiver receiver = safeGetExpressionReceiver(facade, binaryExpression.getLeft(), context.replaceScope(scope));
+        FunctionDescriptor functionDescriptor = context.replaceScope(scope).resolveCallWithGivenName(
+                CallMaker.makeCall(receiver, binaryExpression),
+                binaryExpression.getOperationReference(),
+                name,
+                receiver);
+        if (functionDescriptor != null) {
+            return functionDescriptor.getReturnType();
+        }
+        return null;
+    }
+
+    @Override
+    public JetType visitDeclaration(JetDeclaration dcl, ExpressionTypingContext context) {
+        context.trace.report(DECLARATION_IN_ILLEGAL_CONTEXT.on(dcl));
+        return null;
+    }
+
+    @Override
+    public JetType visitRootNamespaceExpression(JetRootNamespaceExpression expression, ExpressionTypingContext context) {
+        if (context.namespacesAllowed) {
+            return ExpressionTypingUtils.checkType(JetModuleUtil.getRootNamespaceType(expression), expression, context);
+        }
+        context.trace.report(NAMESPACE_IS_NOT_AN_EXPRESSION.on(expression));
+        return null;
+    }
+
+
+    @Override
+    public JetType visitStringTemplateExpression(JetStringTemplateExpression expression, ExpressionTypingContext contextWithExpectedType) {
+        final ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE);
+        final StringBuilder builder = new StringBuilder();
+        final CompileTimeConstant<?>[] value = new CompileTimeConstant<?>[1];
+        for (JetStringTemplateEntry entry : expression.getEntries()) {
+            entry.accept(new JetVisitorVoid() {
+
+                @Override
+                public void visitStringTemplateEntryWithExpression(JetStringTemplateEntryWithExpression entry) {
+                    JetExpression entryExpression = entry.getExpression();
+                    if (entryExpression != null) {
+                        facade.getType(entryExpression, context.replaceScope(context.scope));
+                    }
+                    value[0] = CompileTimeConstantResolver.OUT_OF_RANGE;
+                }
+
+                @Override
+                public void visitLiteralStringTemplateEntry(JetLiteralStringTemplateEntry entry) {
+                    builder.append(entry.getText());
+                }
+
+                @Override
+                public void visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry) {
+                    // TODO : Check escape
+                    String text = entry.getText();
+                    assert text.length() == 2 && text.charAt(0) == '\\';
+                    char escaped = text.charAt(1);
+
+                    Character character = CompileTimeConstantResolver.translateEscape(escaped);
+                    if (character == null) {
+                        context.trace.report(ILLEGAL_ESCAPE_SEQUENCE.on(entry));
+                        value[0] = CompileTimeConstantResolver.OUT_OF_RANGE;
+                    }
+                    else {
+                        builder.append(character);
+                    }
+                }
+            });
+        }
+        if (value[0] != CompileTimeConstantResolver.OUT_OF_RANGE) {
+            context.trace.record(BindingContext.COMPILE_TIME_VALUE, expression, new StringValue(builder.toString()));
+        }
+        return checkType(context.semanticServices.getStandardLibrary().getStringType(), expression, contextWithExpectedType);
+    }
+
+    @Override
+    public JetType visitAnnotatedExpression(JetAnnotatedExpression expression, ExpressionTypingContext data) {
+        return facade.getType(expression.getBaseExpression(), data);
+    }
+    
+    @Override
+    public JetType visitJetElement(JetElement element, ExpressionTypingContext context) {
+        context.trace.report(UNSUPPORTED.on(element, getClass().getCanonicalName()));
+        return null;
+    }
+}