Merge remote branch 'origin/master'

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,42 @@ 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()};
+    }
+
+    public JetLiteFixture() {
+        myFullDataPath = getTestDataPath();
     }
 
     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 +72,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 +90,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/codegen/CodegenTestCase.java

@@ -1,17 +1,14 @@
 package org.jetbrains.jet.codegen;
 
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.JetLightProjectDescriptor;
+import org.jetbrains.jet.JetLiteFixture;
 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.parsing.JetParsingTest;
-import org.jetbrains.jet.plugin.JetFileType;
 
+import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.HashMap;
@@ -21,8 +18,9 @@ import java.util.Map;
 /**
  * @author yole
  */
-public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
+public abstract class CodegenTestCase extends JetLiteFixture {
     private MyClassLoader myClassLoader;
+    private JetFile myFile;
 
     protected static void assertThrows(Method foo, Class<? extends Throwable> exceptionClass, Object instance, Object... args) throws IllegalAccessException {
         boolean caught = false;
@@ -43,16 +41,24 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
 
     @Override
     protected void tearDown() throws Exception {
+        myFile = null;
         myClassLoader = null;
         super.tearDown();
     }
 
     protected void loadText(final String text) {
-        myFixture.configureByText(JetFileType.INSTANCE, text);
+        myFile = (JetFile) createFile("a.jet", text);
     }
 
-    protected void loadFile(final String name) {
+    @Override
-        myFixture.configureByFile(JetParsingTest.getTestDataDir() + "/codegen/" + name);
+    protected String loadFile(final String name) {
+        try {
+            final String content = doLoadFile(JetParsingTest.getTestDataDir() + "/codegen/", name);
+            myFile = (JetFile) createFile(name, content);
+            return content;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     protected void loadFile() {
@@ -85,8 +91,7 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
         ClassFileFactory codegens = generateClassesInFile();
         CodegensClassLoader loader = new CodegensClassLoader(codegens);
 
-        JetFile jetFile = (JetFile) myFixture.getFile();
+        final JetNamespace namespace = myFile.getRootNamespace();
-        final JetNamespace namespace = jetFile.getRootNamespace();
         String fqName = NamespaceCodegen.getJVMClassName(namespace.getFQName()).replace("/", ".");
         Class<?> namespaceClass = loader.loadClass(fqName);
             Method method = namespaceClass.getMethod("box");
@@ -95,9 +100,8 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
 
     protected String generateToText() {
         GenerationState state = new GenerationState(getProject(), true);
-        JetFile jetFile = (JetFile) myFixture.getFile();
+        AnalyzingUtils.checkForSyntacticErrors(myFile);
-        AnalyzingUtils.checkForSyntacticErrors(jetFile);
+        state.compile(myFile);
-        state.compile(jetFile);
 
         StringBuilder answer = new StringBuilder();
 
@@ -117,8 +121,7 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
     }
 
     protected Class loadRootNamespaceClass(ClassFileFactory state) {
-        JetFile jetFile = (JetFile) myFixture.getFile();
+        final JetNamespace namespace = myFile.getRootNamespace();
-        final JetNamespace namespace = jetFile.getRootNamespace();
         String fqName = NamespaceCodegen.getJVMClassName(namespace.getFQName()).replace("/", ".");
         Map<String, Class> classMap = loadAllClasses(state);
         return classMap.get(fqName);
@@ -151,9 +154,8 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
     protected ClassFileFactory generateClassesInFile() {
         try {
             GenerationState state = new GenerationState(getProject(), false);
-            JetFile jetFile = (JetFile) myFixture.getFile();
+            AnalyzingUtils.checkForSyntacticErrors(myFile);
-            AnalyzingUtils.checkForSyntacticErrors(jetFile);
+            state.compile(myFile);
-            state.compile(jetFile);
 
             return state.getFactory();
         } catch (RuntimeException e) {
@@ -233,10 +235,4 @@ public abstract class CodegenTestCase extends LightCodeInsightFixtureTestCase {
             return super.findClass(name);
         }
     }
-
-    @NotNull
-    @Override
-    protected LightProjectDescriptor getProjectDescriptor() {
-        return JetLightProjectDescriptor.INSTANCE;
-    }
 }

compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java

@@ -2,10 +2,8 @@ package org.jetbrains.jet.codegen;
 
 import jet.IntRange;
 import jet.Tuple2;
-import jet.Tuple3;
 import jet.Tuple4;
 import jet.typeinfo.TypeInfo;
-import org.jetbrains.jet.parsing.JetParsingTest;
 
 import java.awt.*;
 import java.lang.reflect.InvocationTargetException;
@@ -48,7 +46,7 @@ public class NamespaceGenTest extends CodegenTestCase {
     }
 
     public void testLocalProperty() throws Exception {
-        myFixture.configureByFile(JetParsingTest.getTestDataDir() + "/codegen/localProperty.jet");
+        loadFile("localProperty.jet");
         final String text = generateToText();
         System.out.println(text);
 

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

@@ -1,6 +1,6 @@
 package org.jetbrains.jet.types;
 
-import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -18,7 +18,7 @@ import java.util.List;
 /**
  * @author svtk
  */
-public class JetDefaultModalityModifiersTest extends LightDaemonAnalyzerTestCase {
+public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     private JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase();
 
     @Override
@@ -27,7 +27,7 @@ public class JetDefaultModalityModifiersTest extends LightDaemonAnalyzerTestCase
         tc.setUp();
     }
 
-    public static class JetDefaultModalityModifiersTestCase  {
+    public class JetDefaultModalityModifiersTestCase  {
         private ModuleDescriptor root = new ModuleDescriptor("test_root");
         private ClassDescriptorResolver classDescriptorResolver;
         private JetScope scope;

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

@@ -1,7 +1,7 @@
 package org.jetbrains.jet.types;
 
-import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
+import org.jetbrains.jet.JetLiteFixture;
-import com.intellij.openapi.application.PathManager;
+import org.jetbrains.jet.JetTestCaseBase;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
@@ -11,14 +11,11 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.ClassDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
-import org.jetbrains.jet.parsing.JetParsingTest;
-
-import java.io.File;
 
 /**
  * @author abreslav
  */
-public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
+public class JetOverridingTest extends JetLiteFixture {
 
     private ModuleDescriptor root = new ModuleDescriptor("test_root");
     private JetStandardLibrary library;
@@ -35,11 +32,7 @@ public class JetOverridingTest extends LightDaemonAnalyzerTestCase {
 
     @Override
     protected String getTestDataPath() {
-        return getHomeDirectory() + "/compiler/testData";
+        return JetTestCaseBase.getTestDataPathBase();
-    }
-
-    private static String getHomeDirectory() {
-       return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent();
     }
 
     public void testBasic() throws Exception {

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

@@ -1,12 +1,10 @@
 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.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBase;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.JetSemanticServices;
@@ -21,15 +19,13 @@ 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 org.jetbrains.jet.parsing.JetParsingTest;
 
-import java.io.File;
 import java.util.*;
 
 /**
  * @author abreslav
  */
-public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
+public class JetTypeCheckerTest extends JetLiteFixture {
 
     private JetStandardLibrary library;
     private JetSemanticServices semanticServices;
@@ -38,6 +34,10 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
     private JetScope scopeWithImports;
     private TypeResolver typeResolver;
 
+    public JetTypeCheckerTest() {
+        super("");
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
@@ -51,11 +51,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
 
     @Override
     protected String getTestDataPath() {
-        return getHomeDirectory() + "/compiler/testData";
+        return JetTestCaseBase.getTestDataPathBase();
-    }
-
-    private static String getHomeDirectory() {
-       return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent();
     }
 
     public void testConstants() throws Exception {
@@ -544,11 +540,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 = {