GenerationState refactored to be (almost) immutable and methodless (modulo little protection from reuse)

GenerationStrategy introduced to handle separately cases of regular compilation and building of JetLightClasses (this was only real overridable behavior of GenerationState in old code)
state subpackage introduced

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java

@@ -27,13 +27,10 @@ import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiClassImplUtil;
-import com.intellij.psi.impl.PsiManagerImpl;
-import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.impl.java.stubs.PsiClassStub;
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
 import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
 import com.intellij.psi.impl.light.AbstractLightClass;
-import com.intellij.psi.stubs.PsiClassHolderFileStub;
 import com.intellij.psi.stubs.PsiFileStub;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.util.*;
@@ -41,6 +38,8 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -51,14 +50,11 @@ import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetLanguage;
-import org.jetbrains.jet.utils.Progress;
 
 import javax.swing.*;
-import java.util.Collection;
 import java.util.Collections;
 
 public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMarker {
-    private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.asJava.JetLightClass");
     private final static Key<CachedValue<PsiJavaFileStub>> JAVA_API_STUB = Key.create("JAVA_API_STUB");
 
     private final JetFile file;
@@ -179,34 +175,10 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
             throw new IllegalStateException("failed to analyze: " + context.getError(), context.getError());
         }
 
-        final GenerationState state = new GenerationState(project, builderFactory, context, Collections.singletonList(file)) {
-            @Override
-            protected void generateNamespace(FqName fqName, Collection<JetFile> namespaceFiles, CompilationErrorHandler errorHandler, Progress progress) {
-                PsiManager manager = PsiManager.getInstance(project);
-                stubStack.push(answer);
+        final GenerationState state = new GenerationState(project, builderFactory, context, Collections.singletonList(file));
+        final GenerationStrategy strategy = new LightClassGenerationStrategy(this, stubStack, answer);
 
-                answer.setPsiFactory(new ClsWrapperStubPsiFactory());
-                final ClsFileImpl fakeFile =
-                    new ClsFileImpl((PsiManagerImpl)manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
-                        @NotNull
-                        @Override
-                        public PsiClassHolderFileStub getStub() {
-                            return answer;
-                        }
-                    };
-
-                fakeFile.setPhysical(false);
-                answer.setPsi(fakeFile);
-
-                super.generateNamespace(fqName, namespaceFiles, errorHandler, progress);
-                final StubElement pop = stubStack.pop();
-                if (pop != answer) {
-                    LOG.error("Unbalanced stack operations: " + pop);
-                }
-            }
-        };
-
-        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        strategy.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
         state.getFactory().files();
 
         return answer;
@@ -275,4 +247,8 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
         }
         return null;
     }
+
+    public JetFile getFile() {
+        return file;
+    }
 }

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassGenerationStrategy.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.asJava;
+
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.psi.ClassFileViewProvider;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.PsiManagerImpl;
+import com.intellij.psi.impl.compiled.ClsFileImpl;
+import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
+import com.intellij.psi.stubs.PsiClassHolderFileStub;
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.util.containers.Stack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.CompilationErrorHandler;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Collection;
+
+/**
+ * @author alex.tkachman
+*/
+class LightClassGenerationStrategy extends GenerationStrategy {
+    private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.asJava.LightClassGenerationStrategy");
+
+    private final Stack<StubElement> stubStack;
+    private final PsiJavaFileStubImpl answer;
+    private final JetLightClass theClass;
+
+    public LightClassGenerationStrategy(JetLightClass aClass, Stack<StubElement> stubStack, PsiJavaFileStubImpl answer) {
+        this.theClass = aClass;
+        this.stubStack = stubStack;
+        this.answer = answer;
+    }
+
+    @Override
+    public void generateNamespace(
+            GenerationState state,
+            FqName fqName,
+            Collection<JetFile> namespaceFiles,
+            CompilationErrorHandler errorHandler
+    ) {
+        PsiManager manager = PsiManager.getInstance(state.getProject());
+        stubStack.push(answer);
+
+        answer.setPsiFactory(new ClsWrapperStubPsiFactory());
+        final ClsFileImpl fakeFile =
+                new ClsFileImpl((PsiManagerImpl) manager, new ClassFileViewProvider(manager, theClass.getFile().getVirtualFile())) {
+                    @NotNull
+                    @Override
+                    public PsiClassHolderFileStub getStub() {
+                        return answer;
+                    }
+                };
+
+        fakeFile.setPhysical(false);
+        answer.setPsi(fakeFile);
+
+        super.generateNamespace(state, fqName, namespaceFiles, errorHandler);
+        final StubElement pop = stubStack.pop();
+        if (pop != answer) {
+            LOG.error("Unbalanced stack operations: " + pop);
+        }
+    }
+}