JetLiteFixture based on JetCoreEnvironment

compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java

@@ -1,24 +1,22 @@
 package org.jetbrains.jet.cli;
 
 import com.google.common.collect.Lists;
-import com.intellij.core.JavaCoreEnvironment;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
+import org.jetbrains.jet.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
-import org.jetbrains.jet.lang.parsing.JetParserDefinition;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.JavaDefaultImports;
-import org.jetbrains.jet.plugin.JetFileType;
 
 import java.io.File;
 import java.io.IOException;
@@ -42,7 +40,7 @@ public class KotlinCompiler {
             public void dispose() {
             }
         };
-        JavaCoreEnvironment environment = new JavaCoreEnvironment(root);
+        JetCoreEnvironment environment = new JetCoreEnvironment(root);
 
         String javaHome = System.getenv("JAVA_HOME");
         File rtJar = null;
@@ -80,9 +78,6 @@ public class KotlinCompiler {
 
         environment.addToClasspath(rtJar);
 
-        environment.registerFileType(JetFileType.INSTANCE, "kt");
-        environment.registerFileType(JetFileType.INSTANCE, "jet");
-        environment.registerParserDefinition(new JetParserDefinition());
         VirtualFile vFile = environment.getLocalFileSystem().findFileByPath(args [0]);
         if (vFile == null) {
             System.out.print("File not found: " + args[0]);

compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java

@@ -0,0 +1,18 @@
+package org.jetbrains.jet;
+
+import com.intellij.core.JavaCoreEnvironment;
+import com.intellij.openapi.Disposable;
+import org.jetbrains.jet.lang.parsing.JetParserDefinition;
+import org.jetbrains.jet.plugin.JetFileType;
+
+/**
+ * @author yole
+ */
+public class JetCoreEnvironment extends JavaCoreEnvironment {
+    public JetCoreEnvironment(Disposable parentDisposable) {
+        super(parentDisposable);
+        registerFileType(JetFileType.INSTANCE, "kt");
+        registerFileType(JetFileType.INSTANCE, "jet");
+        registerParserDefinition(new JetParserDefinition());
+    }
+}

compiler/tests/org/jetbrains/jet/JetLiteFixture.java

@@ -1,46 +1,20 @@
 package org.jetbrains.jet;
 
-import com.intellij.ide.startup.impl.StartupManagerImpl;
-import com.intellij.lang.*;
-import com.intellij.lang.impl.PsiBuilderFactoryImpl;
-import com.intellij.mock.*;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.EditorFactory;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl;
 import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
-import com.intellij.openapi.fileTypes.FileTypeFactory;
+import com.intellij.openapi.project.Project;
-import com.intellij.openapi.fileTypes.FileTypeManager;
-import com.intellij.openapi.options.SchemesManagerFactory;
-import com.intellij.openapi.progress.impl.ProgressManagerImpl;
-import com.intellij.openapi.startup.StartupManager;
-import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.CharsetToolkit;
-import com.intellij.psi.*;
+import com.intellij.psi.PsiElement;
-import com.intellij.psi.impl.PsiCachedValuesFactory;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiFileFactory;
 import com.intellij.psi.impl.PsiFileFactoryImpl;
-import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
-import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistryImpl;
-import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.testFramework.LightVirtualFile;
-import com.intellij.testFramework.MockSchemesManagerFactory;
-import com.intellij.testFramework.PlatformLiteFixture;
 import com.intellij.testFramework.TestDataFile;
-import com.intellij.util.CachedValuesManagerImpl;
+import com.intellij.testFramework.UsefulTestCase;
-import com.intellij.util.Function;
-import com.intellij.util.messages.MessageBus;
-import com.intellij.util.messages.MessageBusFactory;
 import org.jetbrains.annotations.NonNls;
-import org.jetbrains.jet.lang.parsing.JetParserDefinition;
+import org.jetbrains.jet.plugin.JetLanguage;
-import org.picocontainer.MutablePicoContainer;
-import org.picocontainer.PicoContainer;
-import org.picocontainer.PicoInitializationException;
-import org.picocontainer.PicoIntrospectionException;
-import org.picocontainer.defaults.AbstractComponentAdapter;
 
 import java.io.File;
 import java.io.IOException;
@@ -48,81 +22,38 @@ import java.io.IOException;
 /**
  * @author abreslav
  */
-public abstract class JetLiteFixture extends PlatformLiteFixture {
+public abstract class JetLiteFixture extends UsefulTestCase {
-    protected String myFileExt;
     @NonNls
     protected final String myFullDataPath;
     protected PsiFile myFile;
-    private MockPsiManager myPsiManager;
+    private JetCoreEnvironment myEnvironment;
-    private PsiFileFactoryImpl myFileFactory;
-    protected Language myLanguage;
-    protected final ParserDefinition[] myDefinitions;
 
     public JetLiteFixture(@NonNls String dataPath) {
-        myFileExt = "jet";
         myFullDataPath = getTestDataPath() + "/" + dataPath;
-        myDefinitions = new ParserDefinition[] {new JetParserDefinition()};
     }
 
     protected String getTestDataPath() {
         return JetTestCaseBase.getTestDataPathBase();
     }
 
+    public Project getProject() {
+        return myEnvironment.getProject();
+    }
+
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        initApplication();
+        myEnvironment = new JetCoreEnvironment(getTestRootDisposable());
-        getApplication().getPicoContainer().registerComponent(new AbstractComponentAdapter("com.intellij.openapi.progress.ProgressManager", Object.class) {
+        final File rtJar = new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar");
-            @Override
+        myEnvironment.addToClasspath(rtJar);
-            public Object getComponentInstance(PicoContainer container) throws PicoInitializationException, PicoIntrospectionException {
+        myEnvironment.addToClasspath(new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar"));
-                return new ProgressManagerImpl(getApplication());
-            }
-
-            @Override
-            public void verify(PicoContainer container) throws PicoIntrospectionException {
-            }
-        });
-        Extensions.registerAreaClass("IDEA_PROJECT", null);
-        myProject = disposeOnTearDown(new MockProjectEx(getTestRootDisposable()));
-        myPsiManager = new MockPsiManager(myProject);
-        myFileFactory = new PsiFileFactoryImpl(myPsiManager);
-        final MutablePicoContainer appContainer = getApplication().getPicoContainer();
-        registerComponentInstance(appContainer, MessageBus.class, MessageBusFactory.newMessageBus(getApplication()));
-        registerComponentInstance(appContainer, SchemesManagerFactory.class, new MockSchemesManagerFactory());
-        final MockEditorFactory editorFactory = new MockEditorFactory();
-        registerComponentInstance(appContainer, EditorFactory.class, editorFactory);
-        registerComponentInstance(appContainer, FileDocumentManager.class, new MockFileDocumentManagerImpl(new Function<CharSequence, Document>() {
-            @Override
-            public Document fun(CharSequence charSequence) {
-                return editorFactory.createDocument(charSequence);
-            }
-        }, FileDocumentManagerImpl.DOCUMENT_KEY));
-        registerComponentInstance(appContainer, PsiDocumentManager.class, new MockPsiDocumentManager());
-        myLanguage = myLanguage == null && myDefinitions != null && myDefinitions.length > 0
-                     ? myDefinitions[0].getFileNodeType().getLanguage()
-                     : myLanguage;
-        registerComponentInstance(appContainer, FileTypeManager.class, new MockFileTypeManager(new MockLanguageFileType(myLanguage, myFileExt)));
-        registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl());
-        registerApplicationService(DefaultASTFactory.class, new DefaultASTFactoryImpl());
-        registerApplicationService(ReferenceProvidersRegistry.class, new ReferenceProvidersRegistryImpl());
-        myProject.registerService(CachedValuesManager.class, new CachedValuesManagerImpl(myProject, new PsiCachedValuesFactory(myPsiManager)));
-        myProject.registerService(PsiManager.class, myPsiManager);
-        myProject.registerService(StartupManager.class, new StartupManagerImpl(myProject));
-        myProject.registerService(PsiFileFactory.class, new PsiFileFactoryImpl(myPsiManager));
-
-        registerExtensionPoint(FileTypeFactory.FILE_TYPE_FACTORY_EP, FileTypeFactory.class);
-
-        for (ParserDefinition definition : myDefinitions) {
-            addExplicitExtension(LanguageParserDefinitions.INSTANCE, definition.getFileNodeType().getLanguage(), definition);
-        }
     }
 
     @Override
     protected void tearDown() throws Exception {
-        super.tearDown();
         myFile = null;
-        myProject = null;
+        myEnvironment = null;
-        myPsiManager = null;
+        super.tearDown();
     }
 
     protected String loadFile(@NonNls @TestDataFile String name) throws IOException {
@@ -137,13 +68,13 @@ public abstract class JetLiteFixture extends PlatformLiteFixture {
     }
 
     protected PsiFile createPsiFile(String name, String text) {
-        return createFile(name + "." + myFileExt, text);
+        return createFile(name + ".jet", text);
     }
 
     protected PsiFile createFile(@NonNls String name, String text) {
-        LightVirtualFile virtualFile = new LightVirtualFile(name, myLanguage, text);
+        LightVirtualFile virtualFile = new LightVirtualFile(name, JetLanguage.INSTANCE, text);
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
-        return myFileFactory.trySetupPsiForFile(virtualFile, myLanguage, true, false);
+        return ((PsiFileFactoryImpl) PsiFileFactory.getInstance(myEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
     }
 
     protected static void ensureParsed(PsiFile file) {
@@ -155,28 +86,8 @@ public abstract class JetLiteFixture extends PlatformLiteFixture {
         });
     }
 
-    protected <T> void registerApplicationService(final Class<T> aClass, T object) {
-        getApplication().registerService(aClass, object);
-        Disposer.register(myProject, new Disposable() {
-            @Override
-            public void dispose() {
-                getApplication().getPicoContainer().unregisterComponent(aClass.getName());
-            }
-        });
-    }
-
-    protected <T> void addExplicitExtension(final LanguageExtension<T> instance, final Language language, final T object) {
-        instance.addExplicitExtension(language, object);
-        Disposer.register(myProject, new Disposable() {
-            @Override
-            public void dispose() {
-                instance.removeExplicitExtension(language, object);
-            }
-        });
-    }
-
     protected void prepareForTest(String name) throws IOException {
-        String text = loadFile(name + "." + myFileExt);
+        String text = loadFile(name + ".jet");
         createAndCheckPsiFile(name, text);
     }
 

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -1,13 +1,11 @@
 package org.jetbrains.jet.types;
 
 import com.google.common.collect.Sets;
-import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.projectRoots.Sdk;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.JetTestCaseBase;
+import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -29,7 +27,7 @@ import java.util.*;
 /**
  * @author abreslav
  */
-public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
+public class JetTypeCheckerTest extends JetLiteFixture {
 
     private JetStandardLibrary library;
     private JetSemanticServices semanticServices;
@@ -38,6 +36,10 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
     private JetScope scopeWithImports;
     private TypeResolver typeResolver;
 
+    public JetTypeCheckerTest() {
+        super("");
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
@@ -544,11 +546,6 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
         return new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true).resolveType(scope, JetPsiFactory.createType(getProject(), typeStr));
     }
 
-    @Override
-    protected Sdk getProjectJDK() {
-        return JetTestCaseBase.jdkFromIdeaHome();
-    }
-
     private class ClassDefinitions {
         private Map<String, ClassDescriptor> CLASSES = new HashMap<String, ClassDescriptor>();
         private String[] CLASS_DECLARATIONS = {