Convert AnalyzeExhaust to Kotlin and make it a data class

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt

@@ -47,7 +47,7 @@ public fun JetElement.getAnalysisResults(vararg extraFiles: JetFile): AnalyzeExh
 }
 
 public fun JetElement.getBindingContext(): BindingContext {
-    return getAnalysisResults().getBindingContext()
+    return getAnalysisResults().bindingContext
 }
 
 public fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalyzeExhaust {

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt

@@ -110,10 +110,10 @@ private class KotlinResolveCache(
             }
             perFileCache.getAnalysisResults(it)
         }
-        val error = results.firstOrNull { it.isError() }
-        val bindingContext = CompositeBindingContext.create(results.map { it.getBindingContext() })
-        return if (error != null)
-                   AnalyzeExhaust.error(bindingContext, error.getError())
+        val withError = results.firstOrNull { it.isError() }
+        val bindingContext = CompositeBindingContext.create(results.map { it.bindingContext })
+        return if (withError != null)
+                   AnalyzeExhaust.error(bindingContext, withError.error)
                else
                     //TODO: (module refactoring) several elements are passed here in debugger
                    AnalyzeExhaust.success(bindingContext, getLazyResolveSession(elements.first()).getModuleDescriptor())

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -220,7 +220,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
         private fun JetNamedFunction.getParametersForDebugger(): ParametersDescriptor {
             return runReadAction {
                 val parameters = ParametersDescriptor()
-                val bindingContext = getAnalysisResults().getBindingContext()
+                val bindingContext = getAnalysisResults().bindingContext
                 val descriptor = bindingContext[BindingContext.FUNCTION, this]
                 if (descriptor != null) {
                     val receiver = descriptor.getExtensionReceiverParameter()
@@ -245,13 +245,13 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
             return runReadAction {
                 val file = createFileForDebugger(codeFragment, extractedFunction)
 
-                val analyzeExhaust = file.checkForErrors()
+                val (bindingContext, moduleDescriptor) = file.checkForErrors()
 
                 val state = GenerationState(
                         file.getProject(),
                         ClassBuilderFactories.BINARIES,
-                        analyzeExhaust.getModuleDescriptor(),
-                        analyzeExhaust.getBindingContext(),
+                        moduleDescriptor,
+                        bindingContext,
                         listOf(file)
                 )
 
@@ -282,10 +282,10 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
 
                 val analyzeExhaust = this.getAnalysisResults(createFlexibleTypesFile())
                 if (analyzeExhaust.isError()) {
-                    throw EvaluateExceptionUtil.createEvaluateException(analyzeExhaust.getError())
+                    throw EvaluateExceptionUtil.createEvaluateException(analyzeExhaust.error)
                 }
 
-                val bindingContext = analyzeExhaust.getBindingContext()
+                val bindingContext = analyzeExhaust.bindingContext
                 bindingContext.getDiagnostics().firstOrNull { it.getSeverity() == Severity.ERROR }?.let {
                     throw EvaluateExceptionUtil.createEvaluateException(DefaultErrorMessages.RENDERER.render(it))
                 }

idea/src/org/jetbrains/jet/plugin/j2k/J2kPostProcessor.kt

@@ -26,7 +26,7 @@ import com.intellij.psi.PsiElement
 
 public class J2kPostProcessor(override val contextToAnalyzeIn: PsiElement) : PostProcessor {
     override fun analyzeFile(file: JetFile): BindingContext {
-        return file.getAnalysisResults().getBindingContext()
+        return file.getAnalysisResults().bindingContext
     }
 
     override fun doAdditionalProcessing(file: JetFile) {

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -145,8 +145,8 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
     {
         val exhaust = config.currentFile.getAnalysisResults()
-        currentFileContext = exhaust.getBindingContext()
-        currentFileModule = exhaust.getModuleDescriptor()
+        currentFileContext = exhaust.bindingContext
+        currentFileModule = exhaust.moduleDescriptor
     }
 
     public var placement: CallablePlacement by Delegates.notNull()

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createClass/CreateClassFromConstructorCallActionFactory.kt

@@ -39,8 +39,7 @@ public object CreateClassFromConstructorCallActionFactory: JetSingleIntentionAct
 
         val file = fullCallExpr.getContainingFile() as? JetFile ?: return null
 
-        val exhaust = callExpr.getAnalysisResults()
-        val context = exhaust.getBindingContext()
+        val (context, moduleDescriptor) = callExpr.getAnalysisResults()
 
         val call = callExpr.getCall(context) ?: return null
         val targetParent = getTargetParentByCall(call, file) ?: return null
@@ -58,7 +57,7 @@ public object CreateClassFromConstructorCallActionFactory: JetSingleIntentionAct
 
         val classKind = if (inAnnotationEntry) ClassKind.ANNOTATION_CLASS else ClassKind.PLAIN_CLASS
 
-        val (expectedTypeInfo, filter) = fullCallExpr.getInheritableTypeInfo(context, exhaust.getModuleDescriptor(), targetParent)
+        val (expectedTypeInfo, filter) = fullCallExpr.getInheritableTypeInfo(context, moduleDescriptor, targetParent)
         if (!filter(classKind)) return null
 
         val typeArgumentInfos = if (inAnnotationEntry) {

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createClass/CreateClassFromReferenceExpressionActionFactory.kt

@@ -38,8 +38,7 @@ public object CreateClassFromReferenceExpressionActionFactory : JetIntentionActi
 
         val name = refExpr.getReferencedName()
 
-        val exhaust = refExpr.getAnalysisResults()
-        val context = exhaust.getBindingContext()
+        val (context, moduleDescriptor) = refExpr.getAnalysisResults()
 
         val fullCallExpr = refExpr.getParent()?.let {
             when {
@@ -88,7 +87,7 @@ public object CreateClassFromReferenceExpressionActionFactory : JetIntentionActi
         val targetParent = getTargetParentByCall(call, file) ?: return Collections.emptyList()
         if (isInnerClassExpected(call)) return Collections.emptyList()
 
-        val (expectedTypeInfo, filter) = fullCallExpr.getInheritableTypeInfo(context, exhaust.getModuleDescriptor(), targetParent)
+        val (expectedTypeInfo, filter) = fullCallExpr.getInheritableTypeInfo(context, moduleDescriptor, targetParent)
 
         return Arrays.asList(ClassKind.OBJECT, ClassKind.ENUM_ENTRY)
                 .filter {

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt

@@ -67,14 +67,14 @@ object CreateParameterActionFactory: JetSingleIntentionActionFactory() {
 
     override fun createAction(diagnostic: Diagnostic): IntentionAction? {
         val exhaust = (diagnostic.getPsiFile() as? JetFile)?.getAnalysisResults() ?: return null
-        val context = exhaust.getBindingContext()
+        val context = exhaust.bindingContext
 
         val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass<JetSimpleNameExpression>()) ?: return null
         if (refExpr.getQualifiedElement() != refExpr) return null
 
         val varExpected = refExpr.getAssignmentByLHS() != null
 
-        val paramType = refExpr.getExpressionForTypeGuess().guessTypes(context, exhaust.getModuleDescriptor()).let {
+        val paramType = refExpr.getExpressionForTypeGuess().guessTypes(context, exhaust.moduleDescriptor).let {
             when (it.size) {
                 0 -> KotlinBuiltIns.getInstance().getAnyType()
                 1 -> it.first()

idea/tests/org/jetbrains/jet/plugin/decompiler/textBuilder/DecompiledTextConsistencyTest.kt

@@ -66,7 +66,7 @@ class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompile
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                 project, listOf(), BindingTraceContext(), { false },
                 module, null, null
-        ).getModuleDescriptor()
+        ).moduleDescriptor
     }
 
     override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? {