diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 1397a2192d0..7d92d477332 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -15,6 +15,7 @@ + diff --git a/build.xml b/build.xml index 8f7b193af88..326a4af9917 100644 --- a/build.xml +++ b/build.xml @@ -3,9 +3,13 @@ - + + + + + @@ -39,13 +43,22 @@ + - + + + + + + + + + - + @@ -57,6 +70,7 @@ + @@ -70,6 +84,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java b/compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java similarity index 87% rename from compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java rename to compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java index ae74afa756c..4d151946178 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java +++ b/compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java @@ -1,19 +1,16 @@ package org.jetbrains.jet.compiler; -import com.intellij.openapi.Disposable; import com.intellij.openapi.application.PathManager; -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.VirtualFileSystem; import com.intellij.util.Function; import com.intellij.util.Processor; import jet.ExtensionFunction0; -import jet.ExtensionFunction10; -import jet.Function1; import jet.modules.IModuleBuilder; import jet.modules.IModuleSetBuilder; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.JetCoreEnvironment; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GeneratedClassLoader; import org.jetbrains.jet.lang.psi.JetNamespace; @@ -22,7 +19,6 @@ import org.jetbrains.jet.plugin.JetMainDetector; import java.io.*; import java.lang.reflect.Field; -import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; import java.util.Arrays; @@ -30,74 +26,13 @@ import java.util.List; import java.util.jar.*; /** - * The environment for compiling a bunch of source files or - * - * @author yole + * @author alex.tkachman */ -public class CompileEnvironment { - private JetCoreEnvironment myEnvironment; - private final Disposable myRootDisposable; - private PrintStream myErrorStream = System.out; +public abstract class AbstractCompileEnvironment { + protected Project project; - public CompileEnvironment() { - myRootDisposable = new Disposable() { - @Override - public void dispose() { - } - }; - myEnvironment = new JetCoreEnvironment(myRootDisposable); - } + protected abstract void addToClasspath(File file); - public void setErrorStream(PrintStream errorStream) { - myErrorStream = errorStream; - } - - public void dispose() { - Disposer.dispose(myRootDisposable); - } - - public boolean initializeKotlinRuntime() { - return initializeKotlinRuntime(myEnvironment); - } - - public static boolean initializeKotlinRuntime(JetCoreEnvironment environment) { - final File unpackedRuntimePath = getUnpackedRuntimePath(); - if (unpackedRuntimePath != null) { - environment.addToClasspath(unpackedRuntimePath); - } - else { - final File runtimeJarPath = getRuntimeJarPath(); - if (runtimeJarPath != null && runtimeJarPath.exists()) { - environment.addToClasspath(runtimeJarPath); - } - else { - return false; - } - } - return true; - } - - public static File getUnpackedRuntimePath() { - URL url = CompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class"); - if (url != null && url.getProtocol().equals("file")) { - return new File(url.getPath()).getParentFile().getParentFile(); - } - return null; - } - - public static File getRuntimeJarPath() { - URL url = CompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class"); - if (url != null && url.getProtocol().equals("jar")) { - String path = url.getPath(); - return new File(path.substring(path.indexOf(":") + 1, path.indexOf("!/"))); - } - return null; - } - - public void setJavaRuntime(File rtJarPath) { - myEnvironment.addToClasspath(rtJarPath); - } - public static File findRtJar(boolean failOnError) { String javaHome = System.getenv("JAVA_HOME"); File rtJar; @@ -164,6 +99,52 @@ public class CompileEnvironment { return null; } + public abstract VirtualFileSystem getLocalFileSystem(); + + public abstract VirtualFileSystem getJarFileSystem(); + + public Project getProject() { + return project; + } + + public static File getUnpackedRuntimePath() { + URL url = CoreCompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class"); + if (url != null && url.getProtocol().equals("file")) { + return new File(url.getPath()).getParentFile().getParentFile(); + } + return null; + } + + public static File getRuntimeJarPath() { + URL url = CoreCompileEnvironment.class.getClassLoader().getResource("jet/JetObject.class"); + if (url != null && url.getProtocol().equals("jar")) { + String path = url.getPath(); + return new File(path.substring(path.indexOf(":") + 1, path.indexOf("!/"))); + } + return null; + } + + public static boolean initializeKotlinRuntime(AbstractCompileEnvironment environment) { + final File unpackedRuntimePath = getUnpackedRuntimePath(); + if (unpackedRuntimePath != null) { + environment.addToClasspath(unpackedRuntimePath); + } + else { + final File runtimeJarPath = getRuntimeJarPath(); + if (runtimeJarPath != null && runtimeJarPath.exists()) { + environment.addToClasspath(runtimeJarPath); + } + else { + return false; + } + } + return true; + } + + public void setJavaRuntime(File rtJarPath) { + addToClasspath(rtJarPath); + } + public void compileModuleScript(String moduleFile, String jarPath, boolean jarRuntime) { final IModuleSetBuilder moduleSetBuilder = loadModuleScript(moduleFile); if (moduleSetBuilder == null) { @@ -183,11 +164,11 @@ public class CompileEnvironment { } public IModuleSetBuilder loadModuleScript(String moduleFile) { - CompileSession scriptCompileSession = new CompileSession(myEnvironment); + CompileSession scriptCompileSession = new CompileSession(this); scriptCompileSession.addSources(moduleFile); scriptCompileSession.addStdLibSources(); - if (!scriptCompileSession.analyze(myErrorStream)) { + if (!scriptCompileSession.analyze(System.out)) { return null; } final ClassFileFactory factory = scriptCompileSession.generate(); @@ -223,22 +204,22 @@ public class CompileEnvironment { } public ClassFileFactory compileModule(IModuleBuilder moduleBuilder, String directory) { - CompileSession moduleCompileSession = new CompileSession(myEnvironment); + CompileSession moduleCompileSession = new CompileSession(this); moduleCompileSession.addStdLibSources(); for (String sourceFile : moduleBuilder.getSourceFiles()) { moduleCompileSession.addSources(new File(directory, sourceFile).getPath()); } for (String classpathRoot : moduleBuilder.getClasspathRoots()) { - myEnvironment.addToClasspath(new File(classpathRoot)); + addToClasspath(new File(classpathRoot)); } - if (!moduleCompileSession.analyze(myErrorStream)) { + if (!moduleCompileSession.analyze(System.out)) { return null; } return moduleCompileSession.generate(); } private static String getHomeDirectory() { - return new File(PathManager.getResourceRoot(CompileEnvironment.class, "/org/jetbrains/jet/compiler/CompileEnvironment.class")).getParentFile().getParentFile().getParent(); + return new File(PathManager.getResourceRoot(CoreCompileEnvironment.class, "/org/jetbrains/jet/compiler/CoreCompileEnvironment.class")).getParentFile().getParentFile().getParent(); } private static final List sanitized = Arrays.asList("kotlin/", "std/"); @@ -331,10 +312,11 @@ public class CompileEnvironment { } } - public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime) { - CompileSession session = new CompileSession(myEnvironment); + public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime, boolean stdlib) { + CompileSession session = new CompileSession(this); session.addSources(sourceFileOrDir); - session.addStdLibSources(); + if(!stdlib) + session.addStdLibSources(); String mainClass = null; for (JetNamespace namespace : session.getSourceFileNamespaces()) { @@ -343,7 +325,7 @@ public class CompileEnvironment { break; } } - if (!session.analyze(myErrorStream)) { + if (!session.analyze(System.out)) { return; } @@ -376,4 +358,8 @@ public class CompileEnvironment { } } } + + public boolean initializeKotlinRuntime() { + return initializeKotlinRuntime(this); + } } diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java b/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java index 9b4a3391cd2..6945c0a8570 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java +++ b/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java @@ -4,11 +4,12 @@ import com.google.common.base.Predicates; 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.ClassBuilderFactory; import org.jetbrains.jet.codegen.ClassFileFactory; +import org.jetbrains.jet.codegen.CompilationErrorHandler; import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespace; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -18,6 +19,7 @@ import org.jetbrains.jet.plugin.JetFileType; import java.io.File; import java.io.PrintStream; import java.util.ArrayList; +import java.util.Collection; import java.util.List; /** @@ -26,13 +28,13 @@ import java.util.List; * @author yole */ public class CompileSession { - private final JetCoreEnvironment myEnvironment; private final List mySourceFileNamespaces = new ArrayList(); private final List myLibrarySourceFileNamespaces = new ArrayList(); private List myErrors = new ArrayList(); private BindingContext myBindingContext; + private AbstractCompileEnvironment myEnvironment; - public CompileSession(JetCoreEnvironment environment) { + public CompileSession(AbstractCompileEnvironment environment) { myEnvironment = environment; } @@ -50,28 +52,32 @@ public class CompileSession { return; } - addSources(new File(path)); + addSources(new File(path), mySourceFileNamespaces); } - private void addSources(File file) { + private void addSources(File file, List namespaces) { if(file.isDirectory()) { for (File child : file.listFiles()) { - addSources(child); + addSources(child, namespaces); } } else { VirtualFile fileByPath = myEnvironment.getLocalFileSystem().findFileByPath(file.getAbsolutePath()); PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(fileByPath); if(psiFile instanceof JetFile) { - mySourceFileNamespaces.add(((JetFile) psiFile).getRootNamespace()); + namespaces.add(((JetFile) psiFile).getRootNamespace()); } } } public void addSources(VirtualFile vFile) { + addSources(vFile, mySourceFileNamespaces); + } + + public void addSources(VirtualFile vFile, List namespaces) { if (vFile.isDirectory()) { for (VirtualFile virtualFile : vFile.getChildren()) { - addSources(virtualFile); + addSources(virtualFile, namespaces); } } else { @@ -84,10 +90,28 @@ public class CompileSession { } } + public void addSources(VirtualFile[] allFiles) { + for(VirtualFile vFile: allFiles) { + if (vFile.getFileType() == JetFileType.INSTANCE) { + PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(vFile); + if (psiFile instanceof JetFile) { + mySourceFileNamespaces.add(((JetFile) psiFile).getRootNamespace()); + } + } + } + } + public List getSourceFileNamespaces() { return mySourceFileNamespaces; } + public BindingContext analyze() { + List allNamespaces = new ArrayList(mySourceFileNamespaces); + allNamespaces.addAll(myLibrarySourceFileNamespaces); + return AnalyzerFacade.analyzeNamespacesWithJavaIntegration( + myEnvironment.getProject(), allNamespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); + } + public boolean analyze(final PrintStream out) { if (!myErrors.isEmpty()) { for (String error : myErrors) { @@ -95,18 +119,19 @@ public class CompileSession { } return false; } - List allNamespaces = new ArrayList(mySourceFileNamespaces); - allNamespaces.addAll(myLibrarySourceFileNamespaces); - myBindingContext = AnalyzerFacade.analyzeNamespacesWithJavaIntegration( - myEnvironment.getProject(), allNamespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); + myBindingContext = analyze(); ErrorCollector errorCollector = new ErrorCollector(myBindingContext); errorCollector.report(out); return !errorCollector.hasErrors; } public ClassFileFactory generate() { + return generate(CompilationErrorHandler.THROW_EXCEPTION); + } + + public ClassFileFactory generate(CompilationErrorHandler handler) { GenerationState generationState = new GenerationState(myEnvironment.getProject(), ClassBuilderFactory.BINARIES); - generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces); + generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces, handler); return generationState.getFactory(); } @@ -117,16 +142,25 @@ public class CompileSession { } public boolean addStdLibSources() { - final File unpackedRuntimePath = CompileEnvironment.getUnpackedRuntimePath(); + return addStdLibSources(false); + } + + public boolean addStdLibSources(boolean forAnalize) { + /* + @todo + We add sources as library sources in case of jar + but as regular one if there is no jar + */ + final File unpackedRuntimePath = CoreCompileEnvironment.getUnpackedRuntimePath(); if (unpackedRuntimePath != null) { - addSources(new File(unpackedRuntimePath, "../../../stdlib/ktSrc").getAbsoluteFile()); + addSources(new File(unpackedRuntimePath, "stdlib/ktSrc").getAbsoluteFile(), forAnalize ? myLibrarySourceFileNamespaces : mySourceFileNamespaces); } else { - final File runtimeJarPath = CompileEnvironment.getRuntimeJarPath(); + final File runtimeJarPath = CoreCompileEnvironment.getRuntimeJarPath(); if (runtimeJarPath != null && runtimeJarPath.exists()) { VirtualFile runtimeJar = myEnvironment.getLocalFileSystem().findFileByPath(runtimeJarPath.getAbsolutePath()); VirtualFile jarRoot = myEnvironment.getJarFileSystem().findFileByPath(runtimeJar.getPath() + "!/stdlib/ktSrc"); - addSources(jarRoot); + addSources(jarRoot, myLibrarySourceFileNamespaces); } else { return false; @@ -134,4 +168,8 @@ public class CompileSession { } return true; } + + public List getLibrarySourceFileNamespaces() { + return myLibrarySourceFileNamespaces; + } } diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java b/compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java new file mode 100644 index 00000000000..d612ee0764a --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java @@ -0,0 +1,84 @@ +package org.jetbrains.jet.compiler; + +import com.intellij.openapi.Disposable; +import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.vfs.VirtualFileSystem; +import com.intellij.util.Processor; +import jet.ExtensionFunction0; +import jet.modules.IModuleBuilder; +import jet.modules.IModuleSetBuilder; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.JetCoreEnvironment; +import org.jetbrains.jet.codegen.ClassFileFactory; +import org.jetbrains.jet.codegen.GeneratedClassLoader; +import org.jetbrains.jet.lang.psi.JetNamespace; +import org.jetbrains.jet.lang.psi.JetPsiUtil; +import org.jetbrains.jet.plugin.JetMainDetector; + +import java.io.*; +import java.lang.reflect.Field; +import java.net.URL; +import java.util.Arrays; +import java.util.List; +import java.util.jar.*; + +/** + * The environment for compiling a bunch of source files or + * + * @author yole + * @author alex.tkachman + */ +public class CoreCompileEnvironment extends AbstractCompileEnvironment { + private final Disposable myRootDisposable; + private final VirtualFileSystem localFileSystem; + private VirtualFileSystem jarFileSystem; + private JetCoreEnvironment myEnvironment; + + public CoreCompileEnvironment() { + myRootDisposable = new Disposable() { + @Override + public void dispose() { + } + }; + myEnvironment = new JetCoreEnvironment(myRootDisposable); + localFileSystem = myEnvironment.getLocalFileSystem(); + jarFileSystem = myEnvironment.getJarFileSystem(); + project = myEnvironment.getProject(); + } + + public CoreCompileEnvironment(JetCoreEnvironment myEnvironment) { + this.myRootDisposable = null; + this.myEnvironment = myEnvironment; + localFileSystem = myEnvironment.getLocalFileSystem(); + jarFileSystem = myEnvironment.getJarFileSystem(); + project = myEnvironment.getProject(); + } + + public void dispose() { + if(myRootDisposable != null) + Disposer.dispose(myRootDisposable); + } + + @Override + public void addToClasspath(File file) { + myEnvironment.addToClasspath(file); + } + + @Override + public VirtualFileSystem getLocalFileSystem() { + return localFileSystem; + } + + @Override + public Project getProject() { + return project; + } + + @Override + public VirtualFileSystem getJarFileSystem() { + return jarFileSystem; + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java index 56db85a522d..4b82fa150ce 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java @@ -2,7 +2,8 @@ package org.jetbrains.jet.cli; import com.sampullara.cli.Args; import com.sampullara.cli.Argument; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.AbstractCompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.compiler.CompileEnvironmentException; /** @@ -25,6 +26,8 @@ public class KotlinCompiler { public String module; @Argument(value = "includeRuntime", description = "include Kotlin runtime in to resulting jar") public boolean includeRuntime; + @Argument(value = "stdlib", description = "means that we compile stdlib itself") + public boolean stdlib; } public static void main(String[] args) { @@ -39,10 +42,10 @@ public class KotlinCompiler { return; } - CompileEnvironment environment = new CompileEnvironment(); + CoreCompileEnvironment environment = new CoreCompileEnvironment(); try { - environment.setJavaRuntime(CompileEnvironment.findRtJar(true)); + environment.setJavaRuntime(AbstractCompileEnvironment.findRtJar(true)); if (!environment.initializeKotlinRuntime()) { System.out.println("No runtime library found"); return; @@ -53,7 +56,7 @@ public class KotlinCompiler { return; } else { - environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime); + environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime, arguments.stdlib); } } catch (CompileEnvironmentException e) { System.out.println(e.getMessage()); diff --git a/compiler/testData/compiler/smoke/Smoke.kts b/compiler/testData/compiler/smoke/Smoke.kts index d9429cd1b65..6bebb8d422c 100644 --- a/compiler/testData/compiler/smoke/Smoke.kts +++ b/compiler/testData/compiler/smoke/Smoke.kts @@ -1,6 +1,7 @@ import kotlin.modules.* val modules = module("smoke") { - source files "Smoke.kt" + source files "src/Smoke.kt" + testSource files "test/SmokeTest.kt" jar name System.getProperty("java.io.tmpdir") + "/smoke.jar" } diff --git a/compiler/testData/compiler/smoke/Smoke.kt b/compiler/testData/compiler/smoke/src/Smoke.kt similarity index 100% rename from compiler/testData/compiler/smoke/Smoke.kt rename to compiler/testData/compiler/smoke/src/Smoke.kt diff --git a/compiler/testData/compiler/smoke/test/SmokeTest.kt b/compiler/testData/compiler/smoke/test/SmokeTest.kt new file mode 100644 index 00000000000..8f5a1b26fef --- /dev/null +++ b/compiler/testData/compiler/smoke/test/SmokeTest.kt @@ -0,0 +1,9 @@ +import std.io + +import junit.framework.* + +class SmokeTest() : TestCase() { + fun testMe() { + println("test") + } +} diff --git a/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java index 8bb9e576bc6..377d79664a2 100644 --- a/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java @@ -12,7 +12,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.ClassBuilderFactory; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.plugin.JetLanguage; @@ -36,7 +36,7 @@ public class CompileJavaAgainstKotlinTest extends UsefulTestCase { private final File ktFile; private final File javaFile; - private JetCoreEnvironment jetCoreEnvironment; + private CoreCompileEnvironment jetCoreEnvironment; private File tmpdir; public CompileJavaAgainstKotlinTest(File ktFile) { @@ -80,7 +80,7 @@ public class CompileJavaAgainstKotlinTest extends UsefulTestCase { ClassFileFactory classFileFactory = state.getFactory(); - CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); + CoreCompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); Disposer.dispose(myTestRootDisposable); diff --git a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java index 9ff4e21f148..6520cf84a09 100644 --- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -14,7 +14,8 @@ import com.intellij.testFramework.LightVirtualFile; import com.intellij.testFramework.TestDataFile; import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NonNls; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.AbstractCompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.plugin.JetLanguage; @@ -28,7 +29,7 @@ public abstract class JetLiteFixture extends UsefulTestCase { @NonNls protected final String myFullDataPath; protected JetFile myFile; - protected JetCoreEnvironment myEnvironment; + protected CoreCompileEnvironment myEnvironment; public JetLiteFixture(@NonNls String dataPath) { myFullDataPath = getTestDataPath() + "/" + dataPath; @@ -57,8 +58,8 @@ public abstract class JetLiteFixture extends UsefulTestCase { } protected void createEnvironmentWithFullJdk() { - myEnvironment = new JetCoreEnvironment(getTestRootDisposable()); - final File rtJar = CompileEnvironment.findRtJar(true); + myEnvironment = new CoreCompileEnvironment(new JetCoreEnvironment(getTestRootDisposable())); + final File rtJar = AbstractCompileEnvironment.findRtJar(true); myEnvironment.addToClasspath(rtJar); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 14f979b6bc2..636c2edf393 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -3,6 +3,7 @@ package org.jetbrains.jet; import com.google.common.collect.Lists; import com.intellij.openapi.Disposable; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Severity; @@ -137,12 +138,12 @@ public class JetTestUtils { } - public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable) { + public static CoreCompileEnvironment createEnvironmentWithMockJdk(Disposable disposable) { JetCoreEnvironment environment = new JetCoreEnvironment(disposable); final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar"); environment.addToClasspath(rtJar); environment.addToClasspath(new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar")); - return environment; + return new CoreCompileEnvironment(environment); } diff --git a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java index 483903af1de..254fe82f6af 100644 --- a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java +++ b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java @@ -13,7 +13,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.ClassBuilderFactory; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; @@ -49,7 +49,7 @@ public class ReadClassDataTest extends UsefulTestCase { } }; - private JetCoreEnvironment jetCoreEnvironment; + private CoreCompileEnvironment jetCoreEnvironment; private File tmpdir; private final File testFile; @@ -72,7 +72,7 @@ public class ReadClassDataTest extends UsefulTestCase { } private void createMockCoreEnvironment() { - jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable); + jetCoreEnvironment = new CoreCompileEnvironment(new JetCoreEnvironment(myTestRootDisposable)); final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar"); jetCoreEnvironment.addToClasspath(rtJar); @@ -95,7 +95,7 @@ public class ReadClassDataTest extends UsefulTestCase { ClassFileFactory classFileFactory = state.getFactory(); - CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); + CoreCompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); NamespaceDescriptor namespaceFromSource = (NamespaceDescriptor) bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiFile.getRootNamespace()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java index 6c26a8833ee..24b8a0d10af 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java @@ -1,20 +1,7 @@ package org.jetbrains.jet.codegen; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.openapi.vfs.CharsetToolkit; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiFile; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.compiler.CompileSession; -import org.jetbrains.jet.lang.psi.JetNamespace; -import org.jetbrains.jet.lang.resolve.AnalyzingUtils; -import org.jetbrains.jet.parsing.JetParsingTest; - -import java.io.File; -import java.io.IOException; -import java.util.List; /** * @author alex.tkachman @@ -46,7 +33,7 @@ public class StdlibTest extends CodegenTestCase { protected ClassFileFactory generateClassesInFile() { try { CompileSession session = new CompileSession(myEnvironment); - CompileEnvironment.initializeKotlinRuntime(myEnvironment); + CoreCompileEnvironment.initializeKotlinRuntime(myEnvironment); session.addSources(myFile.getVirtualFile()); session.addStdLibSources(); diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java b/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java index 520dee18d48..2a58a8e8902 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java @@ -19,11 +19,11 @@ import java.util.jar.JarInputStream; * @author alex.tkachman */ public class CompileEnvironmentTest extends TestCase { - private CompileEnvironment environment; + private CoreCompileEnvironment environment; protected void setUp() throws Exception { super.setUp(); - environment = new CompileEnvironment(); + environment = new CoreCompileEnvironment(); } @Override @@ -33,7 +33,7 @@ public class CompileEnvironmentTest extends TestCase { } public void testSmoke() throws IOException { - final File activeRtJar = CompileEnvironment.findRtJar(true); + final File activeRtJar = AbstractCompileEnvironment.findRtJar(true); environment.setJavaRuntime(activeRtJar); environment.initializeKotlinRuntime(); final String testDataDir = JetParsingTest.getTestDataDir() + "/compiler/smoke/"; @@ -45,7 +45,7 @@ public class CompileEnvironmentTest extends TestCase { assertNotNull(factory.asBytes("Smoke/namespace.class")); ByteArrayOutputStream baos = new ByteArrayOutputStream(); - CompileEnvironment.writeToJar(factory, baos, null, false); + CoreCompileEnvironment.writeToJar(factory, baos, null, false); JarInputStream is = new JarInputStream(new ByteArrayInputStream(baos.toByteArray())); final List entries = listEntries(is); assertTrue(entries.contains("Smoke/namespace.class")); @@ -93,7 +93,7 @@ public class CompileEnvironmentTest extends TestCase { tempFile = new File(tempFile.getAbsolutePath()); tempFile.mkdir(); try { - KotlinCompiler.main(Arrays.asList("-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kt", "-output", tempFile.getAbsolutePath()).toArray(new String[0])); + KotlinCompiler.main(Arrays.asList("-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/src/Smoke.kt", "-output", tempFile.getAbsolutePath()).toArray(new String[0])); assertEquals(1, tempFile.listFiles().length); assertEquals(1, tempFile.listFiles()[0].listFiles().length); } diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 6fd690eba51..a5c8de70651 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -13,6 +13,12 @@ + + + org.jetbrains.jet.plugin.compiler.JetLibraryManager + + + diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java index 766868d3fc8..fa7c6f761c8 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java @@ -17,6 +17,7 @@ import com.intellij.psi.PsiManager; import com.intellij.util.Chunk; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.*; +import org.jetbrains.jet.compiler.CompileSession; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetFile; @@ -27,6 +28,7 @@ import org.jetbrains.jet.plugin.JetFileType; import java.io.File; import java.io.IOException; +import java.util.ArrayList; import java.util.List; import static com.intellij.openapi.compiler.CompilerMessageCategory.ERROR; @@ -65,19 +67,12 @@ public class JetCompiler implements TranslatingCompiler { ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { - VirtualFile[] allFiles = compileContext.getCompileScope().getFiles(null, true); + PluginCompilerEnvironment compilerEnvironment = new PluginCompilerEnvironment(compileContext.getProject()); + CompileSession compileSession = new CompileSession(compilerEnvironment); + compileSession.addSources(compileContext.getCompileScope().getFiles(null, true)); + compileSession.addStdLibSources(); - GenerationState generationState = new GenerationState(compileContext.getProject(), ClassBuilderFactory.BINARIES); - List namespaces = Lists.newArrayList(); - for (VirtualFile virtualFile : allFiles) { - PsiFile psiFile = PsiManager.getInstance(compileContext.getProject()).findFile(virtualFile); - if (psiFile instanceof JetFile) { - namespaces.add(((JetFile) psiFile).getRootNamespace()); - } - } - - BindingContext bindingContext = - AnalyzerFacade.analyzeNamespacesWithJavaIntegration(compileContext.getProject(), namespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); + BindingContext bindingContext = compileSession.analyze(); boolean errors = false; for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { @@ -96,7 +91,7 @@ public class JetCompiler implements TranslatingCompiler { } if (!errors) { - generationState.compileCorrectNamespaces(bindingContext, namespaces, new CompilationErrorHandler() { + final ClassFileFactory factory = compileSession.generate(new CompilationErrorHandler() { @Override public void reportException(Throwable exception, String fileUrl) { if(exception instanceof CompilationException) { @@ -107,22 +102,7 @@ public class JetCompiler implements TranslatingCompiler { } } }); -/////////// -// GenerationState generationState2 = new GenerationState(compileContext.getProject(), ClassBuilderFactory.TEXT); -// generationState2.compileCorrectNamespaces(bindingContext, namespaces); -// StringBuilder answer = new StringBuilder(); -// -// final ClassFileFactory factory2 = generationState2.getFactory(); -// List files2 = factory2.files(); -// for (String file : files2) { -// answer.append("@").append(file).append('\n'); -// answer.append(factory2.asText(file)); -// } -// System.out.println(answer.toString()); -/////////// - - final ClassFileFactory factory = generationState.getFactory(); List files = factory.files(); for (String file : files) { File target = new File(outputDir.getPath(), file); @@ -135,23 +115,6 @@ public class JetCompiler implements TranslatingCompiler { } } }); - -// Map moduleMap = new HashMap(); -// -// for (VirtualFile virtualFile : virtualFiles) { -// Module module = compileContext.getModuleByFile(virtualFile); -// ModuleCompileState state = moduleMap.get(module); -// if (state == null) { -// state = new ModuleCompileState(compileContext, module, outputSink); -// moduleMap.put(module, state); -// } -// state.compile(virtualFile); -// } -// -// for (ModuleCompileState state : moduleMap.values()) { -// state.done(); -// } - } private void report(Diagnostic diagnostic, CompilerMessageCategory severity, CompileContext compileContext) { diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java b/idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java new file mode 100644 index 00000000000..95bb78171da --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java @@ -0,0 +1,105 @@ +package org.jetbrains.jet.plugin.compiler; + +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.module.ModuleComponent; +import com.intellij.openapi.roots.LibraryOrderEntry; +import com.intellij.openapi.roots.ModifiableRootModel; +import com.intellij.openapi.roots.ModuleRootManager; +import com.intellij.openapi.roots.OrderRootType; +import com.intellij.openapi.roots.impl.ModuleLibraryTable; +import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable; +import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.roots.libraries.LibraryTable; +import com.intellij.openapi.util.Computable; +import com.intellij.openapi.vfs.LocalFileSystem; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.compiler.AbstractCompileEnvironment; + +import java.io.File; + +/** + * @author alex.tkachman + */ +public class JetLibraryManager implements ModuleComponent { + public static final String KOTLIN_STD_LIB = "KotlinStdLib"; + private Module module; + private Library kotlin; + + public JetLibraryManager(Module module) { + this.module = module; + } + + @Override + public void projectOpened() { + } + + @Override + public void projectClosed() { + } + + @Override + public void moduleAdded() { + if(ApplicationManager.getApplication().isUnitTestMode()) + return; + + final LibraryTable libraryTable = ProjectLibraryTable.getInstance(module.getProject()); + kotlin = ApplicationManager.getApplication().runReadAction(new Computable() { + @Override + public Library compute() { + return libraryTable.getLibraryByName(KOTLIN_STD_LIB); + } + }); + if(kotlin == null) { + kotlin = ApplicationManager.getApplication().runWriteAction(new Computable() { + @Override + public Library compute() { + Library library = libraryTable.createLibrary(KOTLIN_STD_LIB); + Library.ModifiableModel modifiableModel = library.getModifiableModel(); + final File unpackedRuntimePath = AbstractCompileEnvironment.getUnpackedRuntimePath(); + if (unpackedRuntimePath != null) { + modifiableModel.addRoot(LocalFileSystem.getInstance().findFileByIoFile(unpackedRuntimePath), OrderRootType.CLASSES); + } + else { + final File runtimeJarPath = AbstractCompileEnvironment.getRuntimeJarPath(); + if (runtimeJarPath != null && runtimeJarPath.exists()) { + modifiableModel.addRoot(LocalFileSystem.getInstance().findFileByIoFile(unpackedRuntimePath), OrderRootType.CLASSES); + } + else { + // todo + } + } + modifiableModel.commit(); + return library; + } + }); + } + + ModuleRootManager rootManager = ModuleRootManager.getInstance(module); + final ModifiableRootModel modifiableModel = rootManager.getModifiableModel(); + LibraryOrderEntry libraryOrderEntry = modifiableModel.findLibraryOrderEntry(kotlin); + if(libraryOrderEntry == null) { + modifiableModel.addLibraryEntry(kotlin); + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + modifiableModel.commit(); + } + }); + } + } + + @Override + public void initComponent() { + } + + @Override + public void disposeComponent() { + } + + @NotNull + @Override + public String getComponentName() { + return JetLibraryManager.class.getCanonicalName(); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java b/idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java new file mode 100644 index 00000000000..253ed52c8fb --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java @@ -0,0 +1,34 @@ +package org.jetbrains.jet.plugin.compiler; + +import com.intellij.openapi.compiler.CompileContext; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.vfs.JarFileSystem; +import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.openapi.vfs.VirtualFileSystem; +import org.jetbrains.jet.compiler.AbstractCompileEnvironment; + +import java.io.File; + +/** + * @author alex.tkachman + */ +public class PluginCompilerEnvironment extends AbstractCompileEnvironment { + public PluginCompilerEnvironment(Project project) { + this.project = project; + } + + @Override + protected void addToClasspath(File file) { + throw new UnsupportedOperationException(); + } + + @Override + public VirtualFileSystem getLocalFileSystem() { + return LocalFileSystem.getInstance(); + } + + @Override + public VirtualFileSystem getJarFileSystem() { + return JarFileSystem.getInstance(); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java b/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java index b858df279df..0bfddc50a8c 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java @@ -11,6 +11,7 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.compiler.CompileSession; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -40,6 +41,11 @@ public final class WholeProjectAnalyzerFacade { final Set namespaces = Sets.newLinkedHashSet(); final ProjectRootManager rootManager = ProjectRootManager.getInstance(project); + PluginCompilerEnvironment environment = new PluginCompilerEnvironment(project); + CompileSession session = new CompileSession(environment); + session.addStdLibSources(true); + namespaces.addAll(session.getLibrarySourceFileNamespaces()); + if (rootManager != null /* && !ApplicationManager.getApplication().isUnitTestMode() */) { VirtualFile[] contentRoots = rootManager.getContentRoots(); diff --git a/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java b/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java index a8cb46e5e83..b8f4d1b96cb 100644 --- a/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java +++ b/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java @@ -7,7 +7,8 @@ import com.intellij.openapi.progress.impl.ProgressManagerImpl; import com.intellij.pom.PomModel; import com.intellij.pom.core.impl.PomModelImpl; import org.jetbrains.jet.JetCoreEnvironment; -import org.jetbrains.jet.compiler.CompileEnvironment; +import org.jetbrains.jet.compiler.AbstractCompileEnvironment; +import org.jetbrains.jet.compiler.CoreCompileEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespace; import org.jetbrains.jet.lang.psi.JetPsiFactory; @@ -61,9 +62,9 @@ public class NamespaceToPackage { } }); - CompileEnvironment compileEnvironment = new CompileEnvironment(); + CoreCompileEnvironment compileEnvironment = new CoreCompileEnvironment(); - compileEnvironment.setJavaRuntime(CompileEnvironment.findRtJar(true)); + compileEnvironment.setJavaRuntime(AbstractCompileEnvironment.findRtJar(true)); if (!compileEnvironment.initializeKotlinRuntime()) { System.out.println("foo"); } diff --git a/stdlib/ktSrc/Arrays.kt b/stdlib/ktSrc/stdlib/ktSrc/Arrays.kt similarity index 100% rename from stdlib/ktSrc/Arrays.kt rename to stdlib/ktSrc/stdlib/ktSrc/Arrays.kt diff --git a/stdlib/ktSrc/Filter.kt b/stdlib/ktSrc/stdlib/ktSrc/Filter.kt similarity index 100% rename from stdlib/ktSrc/Filter.kt rename to stdlib/ktSrc/stdlib/ktSrc/Filter.kt diff --git a/stdlib/ktSrc/Iterators.kt b/stdlib/ktSrc/stdlib/ktSrc/Iterators.kt similarity index 100% rename from stdlib/ktSrc/Iterators.kt rename to stdlib/ktSrc/stdlib/ktSrc/Iterators.kt diff --git a/stdlib/ktSrc/JavaCollections.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaCollections.kt similarity index 100% rename from stdlib/ktSrc/JavaCollections.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaCollections.kt diff --git a/stdlib/ktSrc/JavaIo.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaIo.kt similarity index 100% rename from stdlib/ktSrc/JavaIo.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaIo.kt diff --git a/stdlib/ktSrc/JavaIterables.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaIterables.kt similarity index 100% rename from stdlib/ktSrc/JavaIterables.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaIterables.kt diff --git a/stdlib/ktSrc/JavaIterablesSpecial.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaIterablesSpecial.kt similarity index 100% rename from stdlib/ktSrc/JavaIterablesSpecial.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaIterablesSpecial.kt diff --git a/stdlib/ktSrc/JavaUtil.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaUtil.kt similarity index 100% rename from stdlib/ktSrc/JavaUtil.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaUtil.kt diff --git a/stdlib/ktSrc/JavaUtilMap.kt b/stdlib/ktSrc/stdlib/ktSrc/JavaUtilMap.kt similarity index 100% rename from stdlib/ktSrc/JavaUtilMap.kt rename to stdlib/ktSrc/stdlib/ktSrc/JavaUtilMap.kt diff --git a/stdlib/ktSrc/Standard.kt b/stdlib/ktSrc/stdlib/ktSrc/Standard.kt similarity index 100% rename from stdlib/ktSrc/Standard.kt rename to stdlib/ktSrc/stdlib/ktSrc/Standard.kt diff --git a/stdlib/ktSrc/String.kt b/stdlib/ktSrc/stdlib/ktSrc/String.kt similarity index 100% rename from stdlib/ktSrc/String.kt rename to stdlib/ktSrc/stdlib/ktSrc/String.kt diff --git a/stdlib/ktSrc/System.kt b/stdlib/ktSrc/stdlib/ktSrc/System.kt similarity index 99% rename from stdlib/ktSrc/System.kt rename to stdlib/ktSrc/stdlib/ktSrc/System.kt index 3d7b443991d..2d62972afbe 100644 --- a/stdlib/ktSrc/System.kt +++ b/stdlib/ktSrc/stdlib/ktSrc/System.kt @@ -16,4 +16,4 @@ fun measureTimeNano(block: () -> Unit) : Long { val start = System.nanoTime() block() return System.nanoTime() - start -} \ No newline at end of file +} diff --git a/stdlib/ktSrc/Thread.kt b/stdlib/ktSrc/stdlib/ktSrc/Thread.kt similarity index 100% rename from stdlib/ktSrc/Thread.kt rename to stdlib/ktSrc/stdlib/ktSrc/Thread.kt diff --git a/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt b/stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/generated/ArraysFromJavaCollections.kt rename to stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt diff --git a/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt b/stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt similarity index 100% rename from stdlib/ktSrc/generated/ArraysFromJavaIterables.kt rename to stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt diff --git a/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt b/stdlib/ktSrc/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt rename to stdlib/ktSrc/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt diff --git a/stdlib/ktSrc/generated/StandardFromJavaCollections.kt b/stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/generated/StandardFromJavaCollections.kt rename to stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaCollections.kt diff --git a/stdlib/ktSrc/generated/StandardFromJavaIterables.kt b/stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaIterables.kt similarity index 100% rename from stdlib/ktSrc/generated/StandardFromJavaIterables.kt rename to stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaIterables.kt diff --git a/stdlib/ktSrc/modules/ModuleBuilder.kt b/stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt similarity index 77% rename from stdlib/ktSrc/modules/ModuleBuilder.kt rename to stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt index d0f2985880a..fb03beb7448 100644 --- a/stdlib/ktSrc/modules/ModuleBuilder.kt +++ b/stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt @@ -21,9 +21,13 @@ class ModuleSetBuilder(): IModuleSetBuilder { override fun getModules(): List? = modules } -class SourcesBuilder(val parent: ModuleBuilder) { - fun files(pattern: String) { - parent.addSourceFiles(pattern) +class SourcesBuilder() { + protected val sourceFiles: ArrayList = ArrayList() + + fun files(vararg pattern: String) { + for(p in pattern) { + sourceFiles.add(p) + } } } @@ -40,23 +44,18 @@ class JarBuilder(val parent: ModuleBuilder) { } open class ModuleBuilder(val name: String): IModuleBuilder { - val sourceFiles: ArrayList = ArrayList() + val source = SourcesBuilder() + val testSource = SourcesBuilder() + val classpathRoots: ArrayList = ArrayList() var _jarName: String? = null - val source: SourcesBuilder - get() = SourcesBuilder(this) - val classpath: ClasspathBuilder get() = ClasspathBuilder(this) val jar: JarBuilder get() = JarBuilder(this) - fun addSourceFiles(pattern: String) { - sourceFiles.add(pattern) - } - fun addClasspathEntry(name: String) { classpathRoots.add(name) } @@ -65,7 +64,8 @@ open class ModuleBuilder(val name: String): IModuleBuilder { _jarName = name } - override fun getSourceFiles(): List? = sourceFiles + override fun getSourceFiles(): List? = source.sourceFiles + override fun getTestSourceFiles(): List? = testSource.sourceFiles override fun getClasspathRoots(): List? = classpathRoots override fun getModuleName(): String? = name override fun getJarName(): String? = _jarName diff --git a/stdlib/src/jet/modules/IModuleBuilder.java b/stdlib/src/jet/modules/IModuleBuilder.java index f455eb5fabc..419bdd9c44f 100644 --- a/stdlib/src/jet/modules/IModuleBuilder.java +++ b/stdlib/src/jet/modules/IModuleBuilder.java @@ -8,6 +8,7 @@ import java.util.List; public interface IModuleBuilder { String getModuleName(); List getSourceFiles(); + List getTestSourceFiles(); List getClasspathRoots(); String getJarName(); } diff --git a/templatelib/templatelib.iml b/templatelib/templatelib.iml index 148c33735b9..14ccb779e04 100644 --- a/templatelib/templatelib.iml +++ b/templatelib/templatelib.iml @@ -8,8 +8,8 @@ - + diff --git a/testlib/testlib.iml b/testlib/testlib.iml index d1780f417e7..17a8df813fb 100644 --- a/testlib/testlib.iml +++ b/testlib/testlib.iml @@ -17,7 +17,7 @@ - +