azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote branch 'origin/master'

Browse Source
This commit is contained in:
Andrey Breslav
2011-10-27 20:16:27 +04:00
parent 37c9e00c3f 22afa7dcf4
commit c6c97c749d
7 changed files with 81 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/JetCoreEnvironment.java
+18
View File
@@ -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
+27 -112
View File
@@ -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.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.project.Project;
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.impl.PsiCachedValuesFactory;
import com.intellij.psi.PsiElement;
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.util.Function;
import com.intellij.util.messages.MessageBus;
import com.intellij.util.messages.MessageBusFactory;
import com.intellij.testFramework.UsefulTestCase;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.jet.lang.parsing.JetParserDefinition;
import org.picocontainer.MutablePicoContainer;
import org.picocontainer.PicoContainer;
import org.picocontainer.PicoInitializationException;
import org.picocontainer.PicoIntrospectionException;
import org.picocontainer.defaults.AbstractComponentAdapter;
import org.jetbrains.jet.plugin.JetLanguage;
import java.io.File;
import java.io.IOException;
@@ -48,81 +22,42 @@ import java.io.IOException;
/**
* @author abreslav
*/
public abstract class JetLiteFixture extends PlatformLiteFixture {
protected String myFileExt;
public abstract class JetLiteFixture extends UsefulTestCase {
@NonNls
protected final String myFullDataPath;
protected PsiFile myFile;
private MockPsiManager myPsiManager;
private PsiFileFactoryImpl myFileFactory;
protected Language myLanguage;
protected final ParserDefinition[] myDefinitions;
private JetCoreEnvironment myEnvironment;
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();
getApplication().getPicoContainer().registerComponent(new AbstractComponentAdapter("com.intellij.openapi.progress.ProgressManager", Object.class) {
@Override
public Object getComponentInstance(PicoContainer container) throws PicoInitializationException, PicoIntrospectionException {
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);
}
myEnvironment = new JetCoreEnvironment(getTestRootDisposable());
final File rtJar = new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar");
myEnvironment.addToClasspath(rtJar);
myEnvironment.addToClasspath(new File(JetTestCaseBase.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar"));
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
myFile = null;
myProject = null;
myPsiManager = null;
myEnvironment = 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
+21 -25
View File
@@ -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) {
myFixture.configureByFile(JetParsingTest.getTestDataDir() + "/codegen/" + name);
@Override
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 = jetFile.getRootNamespace();
final JetNamespace namespace = myFile.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(jetFile);
state.compile(jetFile);
AnalyzingUtils.checkForSyntacticErrors(myFile);
state.compile(myFile);
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 = jetFile.getRootNamespace();
final JetNamespace namespace = myFile.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(jetFile);
state.compile(jetFile);
AnalyzingUtils.checkForSyntacticErrors(myFile);
state.compile(myFile);
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
+1 -3
View File
@@ -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
+3 -3
View File
@@ -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
+4 -11
View File
@@ -1,7 +1,7 @@
package org.jetbrains.jet.types;
import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase;
import com.intellij.openapi.application.PathManager;
import org.jetbrains.jet.JetLiteFixture;
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";
}
private static String getHomeDirectory() {
return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent();
return JetTestCaseBase.getTestDataPathBase();
}
public void testBasic() throws Exception {
compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+7 -16
View File
@@ -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";
}
private static String getHomeDirectory() {
return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent();
return JetTestCaseBase.getTestDataPathBase();
}
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 = {