From 4272dafc364e7d53bb2f083baeb6a1eb0750b149 Mon Sep 17 00:00:00 2001 From: svtk Date: Tue, 27 Dec 2011 19:21:33 +0400 Subject: [PATCH 1/6] ReplaceCallFix instead of two ReplaceDotCallWithSafeCall & ReplaceSafeCallWithDotCall --- .../jet/lang/diagnostics/Errors.java | 2 +- .../jet/plugin/quickfix/QuickFixes.java | 6 +- .../jet/plugin/quickfix/ReplaceCallFix.java | 68 +++++++++++++++++++ .../quickfix/ReplaceDotCallWithSafeCall.java | 65 ------------------ .../quickfix/ReplaceSafeCallWithDotCall.java | 56 --------------- .../expressions/afterUnnecessarySafeCall1.kt | 2 +- 6 files changed, 73 insertions(+), 126 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java delete mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceDotCallWithSafeCall.java delete mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index 7f6ce8305d4..3f4b049f685 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -280,7 +280,7 @@ public interface Errors { ParameterizedDiagnosticFactory1 UNSAFE_CALL = ParameterizedDiagnosticFactory1.create(ERROR, "Only safe calls (?.) are allowed on a nullable receiver of type {0}"); SimpleDiagnosticFactory AMBIGUOUS_LABEL = SimpleDiagnosticFactory.create(ERROR, "Ambiguous label"); ParameterizedDiagnosticFactory1 UNSUPPORTED = ParameterizedDiagnosticFactory1.create(ERROR, "Unsupported [{0}]"); - PsiElementOnlyDiagnosticFactory1 UNNECESSARY_SAFE_CALL = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Unnecessary safe call on a non-null receiver of type {0}"); + ParameterizedDiagnosticFactory1 UNNECESSARY_SAFE_CALL = ParameterizedDiagnosticFactory1.create(WARNING, "Unnecessary safe call on a non-null receiver of type {0}"); ParameterizedDiagnosticFactory2 NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = new ParameterizedDiagnosticFactory2(ERROR, "{0} does not refer to a type parameter of {1}") { @Override protected String makeMessageForA(@NotNull JetTypeConstraint jetTypeConstraint) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index 7f3cb3abd63..54a4248003e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -87,7 +87,6 @@ public class QuickFixes { add(Errors.USELESS_ELVIS, RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory()); - add(Errors.UNNECESSARY_SAFE_CALL, ReplaceSafeCallWithDotCall.createFactory()); JetIntentionActionFactory removeRedundantModifierFactory = RemoveModifierFix.createRemoveModifierFromListFactory(true); add(Errors.REDUNDANT_MODIFIER, removeRedundantModifierFactory); @@ -109,7 +108,7 @@ public class QuickFixes { add(Errors.GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, removeModifierFactory); add(Errors.REDUNDANT_MODIFIER_IN_GETTER, removeRedundantModifierFactory); add(Errors.ILLEGAL_MODIFIER, removeModifierFactory); - + add(Errors.PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, AddReturnTypeFix.createFactory()); JetIntentionActionFactory changeToBackingFieldFactory = ChangeToBackingFieldFix.createFactory(); @@ -127,6 +126,7 @@ public class QuickFixes { actionMap.put(Errors.VAL_WITH_SETTER, changeVariableMutabilityFix); actionMap.put(Errors.VAL_REASSIGNMENT, changeVariableMutabilityFix); - actionMap.put(Errors.UNSAFE_CALL, new ReplaceDotCallWithSafeCall()); + actionMap.put(Errors.UNNECESSARY_SAFE_CALL, new ReplaceCallFix(false)); + actionMap.put(Errors.UNSAFE_CALL, new ReplaceCallFix(true)); } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java new file mode 100644 index 00000000000..aa7a0b3d512 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceCallFix.java @@ -0,0 +1,68 @@ +package org.jetbrains.jet.plugin.quickfix; + +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.plugin.JetBundle; + +/** + * @author svtk + */ +public class ReplaceCallFix implements IntentionAction { + private final boolean toSafe; + + public ReplaceCallFix(boolean toSafe) { + this.toSafe = toSafe; + } + + + @NotNull + @Override + public String getText() { + return toSafe ? JetBundle.message("replace.with.safe.call") : JetBundle.message("replace.with.dot.call"); + } + + @NotNull + @Override + public String getFamilyName() { + return toSafe ? JetBundle.message("replace.with.safe.call") : JetBundle.message("replace.with.dot.call"); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + if (file instanceof JetFile) { + return getCallExpression(editor, (JetFile) file) != null; + } + return false; + } + + private JetQualifiedExpression getCallExpression(@NotNull Editor editor, @NotNull JetFile file) { + final PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()); + return PsiTreeUtil.getParentOfType(elementAtCaret, toSafe ? JetDotQualifiedExpression.class : JetSafeQualifiedExpression.class); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + JetQualifiedExpression callExpression = getCallExpression(editor, (JetFile) file); + assert callExpression != null; + + JetExpression selector = callExpression.getSelectorExpression(); + if (selector != null) { + JetQualifiedExpression newElement = (JetQualifiedExpression) JetPsiFactory.createExpression( + project, callExpression.getReceiverExpression().getText() + (toSafe ? "?." : ".") + selector.getText()); + + callExpression.replace(newElement); + } + } + + @Override + public boolean startInWriteAction() { + return true; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceDotCallWithSafeCall.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceDotCallWithSafeCall.java deleted file mode 100644 index 0ddd2731c6f..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceDotCallWithSafeCall.java +++ /dev/null @@ -1,65 +0,0 @@ -package org.jetbrains.jet.plugin.quickfix; - -import com.intellij.codeInsight.intention.IntentionAction; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.util.IncorrectOperationException; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.plugin.JetBundle; - -/** - * @author ignatov - */ -@SuppressWarnings("IntentionDescriptionNotFoundInspection") -public class ReplaceDotCallWithSafeCall implements IntentionAction { - public ReplaceDotCallWithSafeCall() { - } - - @NotNull - @Override - public String getText() { - return JetBundle.message("replace.with.safe.call"); - } - - @NotNull - @Override - public String getFamilyName() { - return JetBundle.message("replace.with.safe.call"); - } - - @Override - public boolean isAvailable(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { - if (file instanceof JetFile) { - return getDotCallExpression(editor, (JetFile) file) != null; - } - return false; - } - - private static JetDotQualifiedExpression getDotCallExpression(@NotNull Editor editor, @NotNull JetFile file) { - final PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()); - return PsiTreeUtil.getParentOfType(elementAtCaret, JetDotQualifiedExpression.class); - } - - @Override - public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { - JetDotQualifiedExpression dotCallExpression = getDotCallExpression(editor, (JetFile) file); - assert dotCallExpression != null; - - JetExpression selector = dotCallExpression.getSelectorExpression(); - if (selector != null) { - JetSafeQualifiedExpression newElement = (JetSafeQualifiedExpression) JetPsiFactory.createExpression( - project, dotCallExpression.getReceiverExpression().getText() + "?." + selector.getText()); - - dotCallExpression.replace(newElement); - } - } - - @Override - public boolean startInWriteAction() { - return true; - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java deleted file mode 100644 index c6a18316996..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallWithDotCall.java +++ /dev/null @@ -1,56 +0,0 @@ -package org.jetbrains.jet.plugin.quickfix; - -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; -import com.intellij.psi.impl.source.codeStyle.CodeEditUtil; -import com.intellij.util.IncorrectOperationException; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.plugin.JetBundle; - -/** - * @author svtk - */ -public class ReplaceSafeCallWithDotCall extends JetIntentionAction { - - public ReplaceSafeCallWithDotCall(@NotNull JetElement element) { - super(element); - } - - @NotNull - @Override - public String getText() { - return JetBundle.message("replace.with.dot.call"); - } - - @NotNull - @Override - public String getFamilyName() { - return JetBundle.message("replace.with.dot.call"); - } - - @Override - public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { - if (element instanceof JetSafeQualifiedExpression) { - JetSafeQualifiedExpression safeQualifiedExpression = (JetSafeQualifiedExpression) element; - JetDotQualifiedExpression newElement = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo"); - - CodeEditUtil.replaceChild(newElement.getNode(), newElement.getSelectorExpression().getNode(), safeQualifiedExpression.getSelectorExpression().getNode()); - CodeEditUtil.replaceChild(newElement.getNode(), newElement.getReceiverExpression().getNode(), safeQualifiedExpression.getReceiverExpression().getNode()); - - element.replace(newElement); - } - } - - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { - @Override - public JetIntentionAction createAction(DiagnosticWithPsiElement diagnostic) { - assert diagnostic.getPsiElement() instanceof JetElement; - return new ReplaceSafeCallWithDotCall((JetElement) diagnostic.getPsiElement()); - } - }; - } -} diff --git a/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt index 55d3d6c64f3..6c1ad9fe270 100644 --- a/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt +++ b/idea/testData/quickfix/expressions/afterUnnecessarySafeCall1.kt @@ -1,4 +1,4 @@ // "Replace with dot call" "true" fun foo(a: Any) { - a.equals(0) + a.equals(0) } From 725bebc23fb8140e238a9fbf96f8c80c45334d74 Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Tue, 27 Dec 2011 17:36:37 +0200 Subject: [PATCH 2/6] work in progress on compiler unification between cli and plugin --- .idea/compiler.xml | 1 + build.xml | 46 +++++- ...t.java => AbstractCompileEnvironment.java} | 148 ++++++++---------- .../jet/compiler/CompileSession.java | 72 +++++++-- .../jet/compiler/CoreCompileEnvironment.java | 84 ++++++++++ .../org/jetbrains/jet/cli/KotlinCompiler.java | 11 +- compiler/testData/compiler/smoke/Smoke.kts | 3 +- .../compiler/smoke/{ => src}/Smoke.kt | 0 .../testData/compiler/smoke/test/SmokeTest.kt | 9 ++ .../jet/CompileJavaAgainstKotlinTest.java | 6 +- .../org/jetbrains/jet/JetLiteFixture.java | 9 +- .../tests/org/jetbrains/jet/JetTestUtils.java | 5 +- .../org/jetbrains/jet/ReadClassDataTest.java | 8 +- .../org/jetbrains/jet/codegen/StdlibTest.java | 17 +- .../jet/compiler/CompileEnvironmentTest.java | 10 +- idea/src/META-INF/plugin.xml | 6 + .../jet/plugin/compiler/JetCompiler.java | 53 +------ .../plugin/compiler/JetLibraryManager.java | 105 +++++++++++++ .../compiler/PluginCompilerEnvironment.java | 34 ++++ .../compiler/WholeProjectAnalyzerFacade.java | 6 + .../jet/shift/NamespaceToPackage.java | 7 +- stdlib/ktSrc/{ => stdlib/ktSrc}/Arrays.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/Filter.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/Iterators.kt | 0 .../{ => stdlib/ktSrc}/JavaCollections.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/JavaIo.kt | 0 .../ktSrc/{ => stdlib/ktSrc}/JavaIterables.kt | 0 .../ktSrc}/JavaIterablesSpecial.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/JavaUtil.kt | 0 .../ktSrc/{ => stdlib/ktSrc}/JavaUtilMap.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/Standard.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/String.kt | 0 stdlib/ktSrc/{ => stdlib/ktSrc}/System.kt | 2 +- stdlib/ktSrc/{ => stdlib/ktSrc}/Thread.kt | 0 .../generated/ArraysFromJavaCollections.kt | 0 .../generated/ArraysFromJavaIterables.kt | 0 .../JavaUtilIterablesFromJavaCollections.kt | 0 .../generated/StandardFromJavaCollections.kt | 0 .../generated/StandardFromJavaIterables.kt | 0 .../ktSrc}/modules/ModuleBuilder.kt | 24 +-- stdlib/src/jet/modules/IModuleBuilder.java | 1 + templatelib/templatelib.iml | 2 +- testlib/testlib.iml | 2 +- 43 files changed, 469 insertions(+), 202 deletions(-) rename compiler/backend/src/org/jetbrains/jet/compiler/{CompileEnvironment.java => AbstractCompileEnvironment.java} (87%) create mode 100644 compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java rename compiler/testData/compiler/smoke/{ => src}/Smoke.kt (100%) create mode 100644 compiler/testData/compiler/smoke/test/SmokeTest.kt create mode 100644 idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java create mode 100644 idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java rename stdlib/ktSrc/{ => stdlib/ktSrc}/Arrays.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/Filter.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/Iterators.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaCollections.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaIo.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaIterables.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaIterablesSpecial.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaUtil.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/JavaUtilMap.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/Standard.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/String.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/System.kt (99%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/Thread.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/generated/ArraysFromJavaCollections.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/generated/ArraysFromJavaIterables.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/generated/JavaUtilIterablesFromJavaCollections.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/generated/StandardFromJavaCollections.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/generated/StandardFromJavaIterables.kt (100%) rename stdlib/ktSrc/{ => stdlib/ktSrc}/modules/ModuleBuilder.kt (77%) 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 @@ - + From fa500f453dc977a55cef45a98cdb528ddee15a1d Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Tue, 27 Dec 2011 17:47:57 +0200 Subject: [PATCH 3/6] kotlin sources on proper place (the same as idea does) --- build.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.xml b/build.xml index 326a4af9917..8150c68078f 100644 --- a/build.xml +++ b/build.xml @@ -59,7 +59,7 @@ - + From 0d5283d0a832463106d7fed7f7d4ee20924bffc0 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Tue, 27 Dec 2011 20:46:39 +0400 Subject: [PATCH 4/6] move tests to subdirectories --- .../fun/{ => genericWithTypeVariables}/FunGenericParam.kt | 0 .../readClass/fun/{ => genericWithTypeVariables}/FunInParam.kt | 0 .../readClass/fun/{ => genericWithTypeVariables}/FunOutParam.kt | 0 .../fun/{ => genericWithTypeVariables}/FunParamUpperClassBound.kt | 0 .../FunParamUpperClassInterfaceBound.kt | 0 .../{ => genericWithTypeVariables}/FunParamUpperInterfaceBound.kt | 0 .../FunParamUpperInterfaceClassBound.kt | 0 .../fun/{ => genericWithoutTypeVariables}/FunClassParamNotNull.kt | 0 .../{ => genericWithoutTypeVariables}/FunClassParamNullable.kt | 0 .../fun/{ => genericWithoutTypeVariables}/FunParamNullable.kt | 0 .../ReturnTypeClassParamNotNull.kt | 0 .../ReturnTypeClassParamNullable.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/ClassFun.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/ExtFun.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/ExtFunInClass.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/FunDefaultArg.kt | 0 .../testData/readClass/fun/{ => nonGeneric}/FunParamNotNull.kt | 0 .../readClass/fun/{ => nonGeneric}/FunVarargCharSequence.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/FunVarargInt.kt | 0 .../testData/readClass/fun/{ => nonGeneric}/ModifierAbstract.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/ModifierOpen.kt | 0 compiler/testData/readClass/fun/{ => nonGeneric}/NsFun.kt | 0 .../testData/readClass/fun/{ => nonGeneric}/ReturnTypeNotNull.kt | 0 .../testData/readClass/fun/{ => nonGeneric}/ReturnTypeNullable.kt | 0 24 files changed, 0 insertions(+), 0 deletions(-) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunGenericParam.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunInParam.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunOutParam.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunParamUpperClassBound.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunParamUpperClassInterfaceBound.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunParamUpperInterfaceBound.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithTypeVariables}/FunParamUpperInterfaceClassBound.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithoutTypeVariables}/FunClassParamNotNull.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithoutTypeVariables}/FunClassParamNullable.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithoutTypeVariables}/FunParamNullable.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithoutTypeVariables}/ReturnTypeClassParamNotNull.kt (100%) rename compiler/testData/readClass/fun/{ => genericWithoutTypeVariables}/ReturnTypeClassParamNullable.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ClassFun.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ExtFun.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ExtFunInClass.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/FunDefaultArg.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/FunParamNotNull.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/FunVarargCharSequence.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/FunVarargInt.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ModifierAbstract.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ModifierOpen.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/NsFun.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ReturnTypeNotNull.kt (100%) rename compiler/testData/readClass/fun/{ => nonGeneric}/ReturnTypeNullable.kt (100%) diff --git a/compiler/testData/readClass/fun/FunGenericParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunGenericParam.kt similarity index 100% rename from compiler/testData/readClass/fun/FunGenericParam.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunGenericParam.kt diff --git a/compiler/testData/readClass/fun/FunInParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunInParam.kt similarity index 100% rename from compiler/testData/readClass/fun/FunInParam.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunInParam.kt diff --git a/compiler/testData/readClass/fun/FunOutParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunOutParam.kt similarity index 100% rename from compiler/testData/readClass/fun/FunOutParam.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunOutParam.kt diff --git a/compiler/testData/readClass/fun/FunParamUpperClassBound.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperClassBound.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamUpperClassBound.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperClassBound.kt diff --git a/compiler/testData/readClass/fun/FunParamUpperClassInterfaceBound.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperClassInterfaceBound.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamUpperClassInterfaceBound.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperClassInterfaceBound.kt diff --git a/compiler/testData/readClass/fun/FunParamUpperInterfaceBound.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperInterfaceBound.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamUpperInterfaceBound.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperInterfaceBound.kt diff --git a/compiler/testData/readClass/fun/FunParamUpperInterfaceClassBound.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperInterfaceClassBound.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamUpperInterfaceClassBound.kt rename to compiler/testData/readClass/fun/genericWithTypeVariables/FunParamUpperInterfaceClassBound.kt diff --git a/compiler/testData/readClass/fun/FunClassParamNotNull.kt b/compiler/testData/readClass/fun/genericWithoutTypeVariables/FunClassParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/fun/FunClassParamNotNull.kt rename to compiler/testData/readClass/fun/genericWithoutTypeVariables/FunClassParamNotNull.kt diff --git a/compiler/testData/readClass/fun/FunClassParamNullable.kt b/compiler/testData/readClass/fun/genericWithoutTypeVariables/FunClassParamNullable.kt similarity index 100% rename from compiler/testData/readClass/fun/FunClassParamNullable.kt rename to compiler/testData/readClass/fun/genericWithoutTypeVariables/FunClassParamNullable.kt diff --git a/compiler/testData/readClass/fun/FunParamNullable.kt b/compiler/testData/readClass/fun/genericWithoutTypeVariables/FunParamNullable.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamNullable.kt rename to compiler/testData/readClass/fun/genericWithoutTypeVariables/FunParamNullable.kt diff --git a/compiler/testData/readClass/fun/ReturnTypeClassParamNotNull.kt b/compiler/testData/readClass/fun/genericWithoutTypeVariables/ReturnTypeClassParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/fun/ReturnTypeClassParamNotNull.kt rename to compiler/testData/readClass/fun/genericWithoutTypeVariables/ReturnTypeClassParamNotNull.kt diff --git a/compiler/testData/readClass/fun/ReturnTypeClassParamNullable.kt b/compiler/testData/readClass/fun/genericWithoutTypeVariables/ReturnTypeClassParamNullable.kt similarity index 100% rename from compiler/testData/readClass/fun/ReturnTypeClassParamNullable.kt rename to compiler/testData/readClass/fun/genericWithoutTypeVariables/ReturnTypeClassParamNullable.kt diff --git a/compiler/testData/readClass/fun/ClassFun.kt b/compiler/testData/readClass/fun/nonGeneric/ClassFun.kt similarity index 100% rename from compiler/testData/readClass/fun/ClassFun.kt rename to compiler/testData/readClass/fun/nonGeneric/ClassFun.kt diff --git a/compiler/testData/readClass/fun/ExtFun.kt b/compiler/testData/readClass/fun/nonGeneric/ExtFun.kt similarity index 100% rename from compiler/testData/readClass/fun/ExtFun.kt rename to compiler/testData/readClass/fun/nonGeneric/ExtFun.kt diff --git a/compiler/testData/readClass/fun/ExtFunInClass.kt b/compiler/testData/readClass/fun/nonGeneric/ExtFunInClass.kt similarity index 100% rename from compiler/testData/readClass/fun/ExtFunInClass.kt rename to compiler/testData/readClass/fun/nonGeneric/ExtFunInClass.kt diff --git a/compiler/testData/readClass/fun/FunDefaultArg.kt b/compiler/testData/readClass/fun/nonGeneric/FunDefaultArg.kt similarity index 100% rename from compiler/testData/readClass/fun/FunDefaultArg.kt rename to compiler/testData/readClass/fun/nonGeneric/FunDefaultArg.kt diff --git a/compiler/testData/readClass/fun/FunParamNotNull.kt b/compiler/testData/readClass/fun/nonGeneric/FunParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/fun/FunParamNotNull.kt rename to compiler/testData/readClass/fun/nonGeneric/FunParamNotNull.kt diff --git a/compiler/testData/readClass/fun/FunVarargCharSequence.kt b/compiler/testData/readClass/fun/nonGeneric/FunVarargCharSequence.kt similarity index 100% rename from compiler/testData/readClass/fun/FunVarargCharSequence.kt rename to compiler/testData/readClass/fun/nonGeneric/FunVarargCharSequence.kt diff --git a/compiler/testData/readClass/fun/FunVarargInt.kt b/compiler/testData/readClass/fun/nonGeneric/FunVarargInt.kt similarity index 100% rename from compiler/testData/readClass/fun/FunVarargInt.kt rename to compiler/testData/readClass/fun/nonGeneric/FunVarargInt.kt diff --git a/compiler/testData/readClass/fun/ModifierAbstract.kt b/compiler/testData/readClass/fun/nonGeneric/ModifierAbstract.kt similarity index 100% rename from compiler/testData/readClass/fun/ModifierAbstract.kt rename to compiler/testData/readClass/fun/nonGeneric/ModifierAbstract.kt diff --git a/compiler/testData/readClass/fun/ModifierOpen.kt b/compiler/testData/readClass/fun/nonGeneric/ModifierOpen.kt similarity index 100% rename from compiler/testData/readClass/fun/ModifierOpen.kt rename to compiler/testData/readClass/fun/nonGeneric/ModifierOpen.kt diff --git a/compiler/testData/readClass/fun/NsFun.kt b/compiler/testData/readClass/fun/nonGeneric/NsFun.kt similarity index 100% rename from compiler/testData/readClass/fun/NsFun.kt rename to compiler/testData/readClass/fun/nonGeneric/NsFun.kt diff --git a/compiler/testData/readClass/fun/ReturnTypeNotNull.kt b/compiler/testData/readClass/fun/nonGeneric/ReturnTypeNotNull.kt similarity index 100% rename from compiler/testData/readClass/fun/ReturnTypeNotNull.kt rename to compiler/testData/readClass/fun/nonGeneric/ReturnTypeNotNull.kt diff --git a/compiler/testData/readClass/fun/ReturnTypeNullable.kt b/compiler/testData/readClass/fun/nonGeneric/ReturnTypeNullable.kt similarity index 100% rename from compiler/testData/readClass/fun/ReturnTypeNullable.kt rename to compiler/testData/readClass/fun/nonGeneric/ReturnTypeNullable.kt From 617b3b5db5da5f4fefccc1a2b7326cd6e6ce4c69 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Tue, 27 Dec 2011 20:46:43 +0400 Subject: [PATCH 5/6] ReadClassDataTest: type variable resolver --- .../jetbrains/jet/codegen/JetTypeMapper.java | 5 + .../resolve/java/JavaDescriptorResolver.java | 156 +++++++++++++++--- .../resolve/java/JavaTypeTransformer.java | 4 +- .../java/JetTypeJetSignatureReader.java | 13 +- .../resolve/java/TypeVariableResolver.java | 12 ++ .../class/ClassParamReferencesParam.kt | 3 + .../class/ClassParamReferencesParam2.kt | 3 + .../readClass/class/ClassTwoParams.kt | 3 + .../readClass/class/ClassTwoParams2.kt | 3 + .../classFun/ClassInParamUsedInFun.kt | 5 + .../readClass/classFun/ClassParamUsedInFun.kt | 5 + .../genericWithTypeVariables/FunParamParam.kt | 3 + .../FunParamReferencesParam.kt | 3 + .../FunParamReferencesParam2.kt | 3 + .../FunParamVaragParam.kt | 3 + .../FunTwoTypeParams.kt | 3 + .../FunTwoTypeParams2.kt | 3 + .../org/jetbrains/jet/ReadClassDataTest.java | 2 +- .../jet/rt/signature/JetSignatureReader.java | 10 +- 19 files changed, 208 insertions(+), 34 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java create mode 100644 compiler/testData/readClass/class/ClassParamReferencesParam.kt create mode 100644 compiler/testData/readClass/class/ClassParamReferencesParam2.kt create mode 100644 compiler/testData/readClass/class/ClassTwoParams.kt create mode 100644 compiler/testData/readClass/class/ClassTwoParams2.kt create mode 100644 compiler/testData/readClass/classFun/ClassInParamUsedInFun.kt create mode 100644 compiler/testData/readClass/classFun/ClassParamUsedInFun.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunParamParam.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam2.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunParamVaragParam.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams.kt create mode 100644 compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams2.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index a6ffef67541..4595f00ed70 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -619,6 +619,11 @@ public class JetTypeMapper { signatureVisitor.writeInterfaceBoundEnd(); } } + if (jetType.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) { + signatureVisitor.writeInterfaceBound(); + mapType(jetType, signatureVisitor); + signatureVisitor.writeInterfaceBoundEnd(); + } } signatureVisitor.writeFormalTypeParameterEnd(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 46dd32c5894..66dfe604e63 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -166,8 +166,17 @@ public class JavaDescriptorResolver { ); classDescriptor.setName(name); + class OuterClassTypeVariableResolver implements TypeVariableResolver { + + @NotNull + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + throw new IllegalStateException("not implemented"); // TODO + } + } + List supertypes = new ArrayList(); - List typeParameters = resolveClassTypeParameters(psiClass, classDescriptor); + List typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver()); classDescriptor.setTypeConstructor(new TypeConstructorImpl( classDescriptor, Collections.emptyList(), // TODO @@ -225,7 +234,10 @@ public class JavaDescriptorResolver { classDescriptor, Collections.emptyList(), // TODO false); - ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters()); + ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor, + constructor.getParameterList().getParameters(), + new TypeParameterListTypeVariableResolver(typeParameters) // TODO: outer too + ); if (valueParameterDescriptors.receiverType != null) { throw new IllegalStateException(); } @@ -242,14 +254,14 @@ public class JavaDescriptorResolver { return classDescriptor; } - private List resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor) { + private List resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) { for (PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) { if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_CLASS.getFqName())) { PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_CLASS_SIGNATURE); if (attributeValue != null) { String typeParametersString = (String) attributeValue.getValue(); if (typeParametersString != null) { - return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor); + return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor, typeVariableResolver); } } } @@ -290,14 +302,20 @@ public class JavaDescriptorResolver { private final PsiTypeParameterListOwner psiOwner; private final String name; private final TypeInfoVariance variance; + private final TypeVariableResolver typeVariableResolver; protected JetSignatureTypeParameterVisitor(DeclarationDescriptor containingDeclaration, PsiTypeParameterListOwner psiOwner, - String name, TypeInfoVariance variance) + String name, TypeInfoVariance variance, TypeVariableResolver typeVariableResolver) { + if (name.isEmpty()) { + throw new IllegalStateException(); + } + this.containingDeclaration = containingDeclaration; this.psiOwner = psiOwner; this.name = name; this.variance = variance; + this.typeVariableResolver = typeVariableResolver; } int index = 0; @@ -307,7 +325,7 @@ public class JavaDescriptorResolver { @Override public JetSignatureVisitor visitClassBound() { - return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) { + return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { if (isJavaLangObject(jetType)) { @@ -320,7 +338,7 @@ public class JavaDescriptorResolver { @Override public JetSignatureVisitor visitInterfaceBound() { - return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) { + return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { upperBounds.add(jetType); @@ -348,12 +366,28 @@ public class JavaDescriptorResolver { /** * @see #resolveMethodTypeParametersFromJetSignature(String, FunctionDescriptor) */ - private List resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz, final JavaClassDescriptor classDescriptor) { + private List resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz, + final JavaClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) { final List r = new ArrayList(); + + class MyTypeVariableResolver implements TypeVariableResolver { + + @NotNull + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + for (TypeParameterDescriptor typeParameter : r) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + return outerClassTypeVariableResolver.getTypeVariable(name); + } + } + new JetSignatureReader(jetSignature).accept(new JetSignatureExceptionsAdapter() { @Override public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) { - return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, variance) { + return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, variance, new MyTypeVariableResolver()) { @Override protected void done(TypeParameterDescriptor typeParameterDescriptor) { r.add(typeParameterDescriptor); @@ -548,12 +582,13 @@ public class JavaDescriptorResolver { } } - public ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration, PsiParameter[] parameters) { + public ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration, + PsiParameter[] parameters, TypeVariableResolver typeVariableResolver) { List result = new ArrayList(); JetType receiverType = null; for (int i = 0, parametersLength = parameters.length; i < parametersLength; i++) { PsiParameter parameter = parameters[i]; - JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i, parameter); + JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i, parameter, typeVariableResolver); if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) { // TODO } else if (meaning.kind == JvmMethodParameterKind.REGULAR) { @@ -601,7 +636,8 @@ public class JavaDescriptorResolver { } @NotNull - private JvmMethodParameterMeaning resolveParameterDescriptor(DeclarationDescriptor containingDeclaration, int i, PsiParameter parameter) { + private JvmMethodParameterMeaning resolveParameterDescriptor(DeclarationDescriptor containingDeclaration, int i, + PsiParameter parameter, TypeVariableResolver typeVariableResolver) { PsiType psiType = parameter.getType(); JetType varargElementType; @@ -663,7 +699,7 @@ public class JavaDescriptorResolver { JetType outType; if (typeFromAnnotation != null && typeFromAnnotation.length() > 0) { - outType = semanticServices.getTypeTransformer().transformToType(typeFromAnnotation); + outType = semanticServices.getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver); } else { outType = semanticServices.getTypeTransformer().transformToType(psiType); } @@ -750,6 +786,26 @@ public class JavaDescriptorResolver { return typeSubstitutor; } + private static class TypeParameterListTypeVariableResolver implements TypeVariableResolver { + + private final List typeParameters; + + private TypeParameterListTypeVariableResolver(List typeParameters) { + this.typeParameters = typeParameters; + } + + @NotNull + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + for (TypeParameterDescriptor typeParameter : typeParameters) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + throw new IllegalStateException("unresolver variable: " + name); // TODO: report properly + } + } + @Nullable public FunctionDescriptor resolveMethodToFunctionDescriptor(DeclarationDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, PsiMethod method) { PsiType returnType = method.getReturnType(); @@ -763,7 +819,17 @@ public class JavaDescriptorResolver { } return functionDescriptor; } - DeclarationDescriptor classDescriptor = method.hasModifierProperty(PsiModifier.STATIC) ? resolveNamespace(method.getContainingClass()) : resolveClass(method.getContainingClass()); + DeclarationDescriptor classDescriptor; + final List classTypeParameters; + if (method.hasModifierProperty(PsiModifier.STATIC)) { + classDescriptor = resolveNamespace(method.getContainingClass()); + classTypeParameters = Collections.emptyList(); + } + else { + ClassDescriptor classClassDescriptor = resolveClass(method.getContainingClass()); + classDescriptor = classClassDescriptor; + classTypeParameters = classClassDescriptor.getTypeConstructor().getParameters(); + } if (classDescriptor == null) { return null; } @@ -774,14 +840,39 @@ public class JavaDescriptorResolver { method.getName() ); methodDescriptorCache.put(method, functionDescriptorImpl); - List typeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl); - ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(functionDescriptorImpl, parameters); + + // TODO: add outer classes + TypeParameterListTypeVariableResolver typeVariableResolverForParameters = new TypeParameterListTypeVariableResolver(classTypeParameters); + + final List methodTypeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters); + + class MethodTypeVariableResolver implements TypeVariableResolver { + + @NotNull + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + for (TypeParameterDescriptor typeParameter : methodTypeParameters) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + for (TypeParameterDescriptor typeParameter : classTypeParameters) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + throw new IllegalStateException("unresolver variable: " + name); // TODO: report properly + } + } + + + ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(functionDescriptorImpl, parameters, new MethodTypeVariableResolver()); functionDescriptorImpl.initialize( valueParameterDescriptors.receiverType, DescriptorUtils.getExpectedThisObjectIfNeeded(classDescriptor), - typeParameters, + methodTypeParameters, valueParameterDescriptors.descriptors, - makeReturnType(returnType, method), + makeReturnType(returnType, method, new MethodTypeVariableResolver()), Modality.convertFromFlags(method.hasModifierProperty(PsiModifier.ABSTRACT), !method.hasModifierProperty(PsiModifier.FINAL)), resolveVisibilityFromPsiModifiers(method) ); @@ -793,14 +884,14 @@ public class JavaDescriptorResolver { return substitutedFunctionDescriptor; } - private List resolveMethodTypeParameters(PsiMethod method, FunctionDescriptorImpl functionDescriptorImpl) { + private List resolveMethodTypeParameters(PsiMethod method, FunctionDescriptorImpl functionDescriptorImpl, TypeVariableResolver classTypeVariableResolver) { for (PsiAnnotation annotation : method.getModifierList().getAnnotations()) { if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_METHOD.getFqName())) { PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD); if (attributeValue != null) { String typeParametersString = (String) attributeValue.getValue(); if (typeParametersString != null) { - List r = resolveMethodTypeParametersFromJetSignature(typeParametersString, method, functionDescriptorImpl); + List r = resolveMethodTypeParametersFromJetSignature(typeParametersString, method, functionDescriptorImpl, classTypeVariableResolver); initializeTypeParameters(method); return r; } @@ -816,13 +907,30 @@ public class JavaDescriptorResolver { /** * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, JavaClassDescriptor) */ - private List resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, final FunctionDescriptor functionDescriptor) { + private List resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, + final FunctionDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver) + { final List r = new ArrayList(); + + class MyTypeVariableResolver implements TypeVariableResolver { + + @NotNull + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + for (TypeParameterDescriptor typeParameter : r) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + return classTypeVariableResolver.getTypeVariable(name); + } + } + new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(new JetSignatureExceptionsAdapter() { @Override public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) { - return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, variance) { + return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, variance, new MyTypeVariableResolver()) { @Override protected void done(TypeParameterDescriptor typeParameterDescriptor) { r.add(typeParameterDescriptor); @@ -834,7 +942,7 @@ public class JavaDescriptorResolver { return r; } - private JetType makeReturnType(PsiType returnType, PsiMethod method) { + private JetType makeReturnType(PsiType returnType, PsiMethod method, TypeVariableResolver typeVariableResolver) { boolean changeNullable = false; boolean nullable = true; @@ -859,7 +967,7 @@ public class JavaDescriptorResolver { } JetType transformedType; if (returnTypeFromAnnotation != null && returnTypeFromAnnotation.length() > 0) { - transformedType = semanticServices.getTypeTransformer().transformToType(returnTypeFromAnnotation); + transformedType = semanticServices.getTypeTransformer().transformToType(returnTypeFromAnnotation, typeVariableResolver); } else { transformedType = semanticServices.getTypeTransformer().transformToType(returnType); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index fde7a02232c..40a6c60b35d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -59,9 +59,9 @@ public class JavaTypeTransformer { } @NotNull - public JetType transformToType(@NotNull String kotlinSignature) { + public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) { final JetType[] r = new JetType[1]; - JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(resolver, standardLibrary) { + JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(resolver, standardLibrary, typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { r[0] = jetType; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index ec5b1b2a7ee..520da450766 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetStandardClasses; @@ -25,10 +26,12 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd private final JavaDescriptorResolver javaDescriptorResolver; private final JetStandardLibrary jetStandardLibrary; + private final TypeVariableResolver typeVariableResolver; - public JetTypeJetSignatureReader(JavaDescriptorResolver javaDescriptorResolver, JetStandardLibrary jetStandardLibrary) { + public JetTypeJetSignatureReader(JavaDescriptorResolver javaDescriptorResolver, JetStandardLibrary jetStandardLibrary, TypeVariableResolver typeVariableResolver) { this.javaDescriptorResolver = javaDescriptorResolver; this.jetStandardLibrary = jetStandardLibrary; + this.typeVariableResolver = typeVariableResolver; } @@ -111,7 +114,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd @Override public JetSignatureVisitor visitTypeArgument(final char wildcard) { - return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary) { + return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary, typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { @@ -122,7 +125,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd @Override public JetSignatureVisitor visitArrayType(final boolean nullable) { - return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary) { + return new JetTypeJetSignatureReader(javaDescriptorResolver, jetStandardLibrary, typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { JetType arrayType = TypeUtils.makeNullableAsSpecified(jetStandardLibrary.getArrayType(jetType), nullable); @@ -133,8 +136,8 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd @Override public void visitTypeVariable(String name, boolean nullable) { - // TODO: need a way to get type TypeParameterDescriptor by name - throw new IllegalStateException(); + JetType r = TypeUtils.makeNullableAsSpecified(typeVariableResolver.getTypeVariable(name).getDefaultType(), nullable); + done(r); } @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java new file mode 100644 index 00000000000..9f391218d72 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java @@ -0,0 +1,12 @@ +package org.jetbrains.jet.lang.resolve.java; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; + +/** + * @author Stepan Koltsov + */ +public interface TypeVariableResolver { + @NotNull + TypeParameterDescriptor getTypeVariable(@NotNull String name); +} diff --git a/compiler/testData/readClass/class/ClassParamReferencesParam.kt b/compiler/testData/readClass/class/ClassParamReferencesParam.kt new file mode 100644 index 00000000000..b33ee9488b6 --- /dev/null +++ b/compiler/testData/readClass/class/ClassParamReferencesParam.kt @@ -0,0 +1,3 @@ +package test + +class ClassParamReferencesParam diff --git a/compiler/testData/readClass/class/ClassParamReferencesParam2.kt b/compiler/testData/readClass/class/ClassParamReferencesParam2.kt new file mode 100644 index 00000000000..6d1879d65ed --- /dev/null +++ b/compiler/testData/readClass/class/ClassParamReferencesParam2.kt @@ -0,0 +1,3 @@ +package test + +class ClassParamReferencesParam diff --git a/compiler/testData/readClass/class/ClassTwoParams.kt b/compiler/testData/readClass/class/ClassTwoParams.kt new file mode 100644 index 00000000000..63df442512e --- /dev/null +++ b/compiler/testData/readClass/class/ClassTwoParams.kt @@ -0,0 +1,3 @@ +package test + +class ClassTwoParams diff --git a/compiler/testData/readClass/class/ClassTwoParams2.kt b/compiler/testData/readClass/class/ClassTwoParams2.kt new file mode 100644 index 00000000000..f3b2e9fff2a --- /dev/null +++ b/compiler/testData/readClass/class/ClassTwoParams2.kt @@ -0,0 +1,3 @@ +package test + +class ClassTwoParams diff --git a/compiler/testData/readClass/classFun/ClassInParamUsedInFun.kt b/compiler/testData/readClass/classFun/ClassInParamUsedInFun.kt new file mode 100644 index 00000000000..cf911c50801 --- /dev/null +++ b/compiler/testData/readClass/classFun/ClassInParamUsedInFun.kt @@ -0,0 +1,5 @@ +package test + +class ClassParamUsedInFun { + fun f(t: T) = 1 +} diff --git a/compiler/testData/readClass/classFun/ClassParamUsedInFun.kt b/compiler/testData/readClass/classFun/ClassParamUsedInFun.kt new file mode 100644 index 00000000000..361a543acde --- /dev/null +++ b/compiler/testData/readClass/classFun/ClassParamUsedInFun.kt @@ -0,0 +1,5 @@ +package test + +class ClassParamUsedInFun { + fun f(t: T) = 1 +} diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamParam.kt new file mode 100644 index 00000000000..a696c85f92c --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamParam.kt @@ -0,0 +1,3 @@ +package test + +fun

funParamParam(a: Int, b: P) = 1 diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam.kt new file mode 100644 index 00000000000..85ff1201f1c --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam.kt @@ -0,0 +1,3 @@ +package test + +fun funParamReferencesParam() = 1 diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam2.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam2.kt new file mode 100644 index 00000000000..df8c64e1ec0 --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamReferencesParam2.kt @@ -0,0 +1,3 @@ +package test + +fun funParamReferencesParam() = 1 diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamVaragParam.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamVaragParam.kt new file mode 100644 index 00000000000..3b3eaac310d --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunParamVaragParam.kt @@ -0,0 +1,3 @@ +package test + +fun

funParamVarargParam(a: Int, vararg b: P) = 1 diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams.kt new file mode 100644 index 00000000000..283a4b9f140 --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams.kt @@ -0,0 +1,3 @@ +package test + +fun funTwoTypeParams() = 1 diff --git a/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams2.kt b/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams2.kt new file mode 100644 index 00000000000..ef12cb5917b --- /dev/null +++ b/compiler/testData/readClass/fun/genericWithTypeVariables/FunTwoTypeParams2.kt @@ -0,0 +1,3 @@ +package test + +fun funTwoTypeParams() = 1 diff --git a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java index 254fe82f6af..ed19afcd79b 100644 --- a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java +++ b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java @@ -403,7 +403,7 @@ public class ReadClassDataTest extends UsefulTestCase { List list = new ArrayList(); for (JetType upper : param.getUpperBounds()) { StringBuilder sb = new StringBuilder(); - new Serializer(sb).serialize(upper); + new ValueParameterSerializer(sb).serialize(upper); list.add(sb.toString()); } Collections.sort(list); diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java index 44112938959..900ec35d2e0 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java @@ -63,7 +63,11 @@ public class JetSignatureReader { if (end < 0) { throw new IllegalStateException(); } - JetSignatureVisitor parameterVisitor = v.visitFormalTypeParameter(signature.substring(pos, end), variance); + String typeParameterName = signature.substring(pos, end); + if (typeParameterName.isEmpty()) { + throw new IllegalStateException("incorrect signature: " + signature); + } + JetSignatureVisitor parameterVisitor = v.visitFormalTypeParameter(typeParameterName, variance); pos = end + 1; c = signature.charAt(pos); @@ -71,12 +75,14 @@ public class JetSignatureReader { pos = parseType(signature, pos, parameterVisitor.visitClassBound()); } - while ((c = signature.charAt(pos++)) == ':') { + while ((c = signature.charAt(pos)) == ':') { + ++pos; pos = parseType(signature, pos, parameterVisitor.visitInterfaceBound()); } parameterVisitor.visitFormalTypeParameterEnd(); } while (c != '>'); + ++pos; } else { pos = 0; } From 4579c9826fa4717e078eb53f3bc48645e5e75412 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 27 Dec 2011 21:26:20 +0400 Subject: [PATCH 6/6] Reverting problematic commits: fa500f453dc977a55cef45a98cdb528ddee15a1d Alex Tkachman Today 19:47 725bebc23fb8140e238a9fbf96f8c80c45334d74 Alex Tkachman Today 19:36 --- .idea/compiler.xml | 1 - build.xml | 48 +----- ...vironment.java => CompileEnvironment.java} | 148 ++++++++++-------- .../jet/compiler/CompileSession.java | 72 ++------- .../jet/compiler/CoreCompileEnvironment.java | 84 ---------- .../org/jetbrains/jet/cli/KotlinCompiler.java | 11 +- .../compiler/smoke/{src => }/Smoke.kt | 0 compiler/testData/compiler/smoke/Smoke.kts | 3 +- .../testData/compiler/smoke/test/SmokeTest.kt | 9 -- .../jet/CompileJavaAgainstKotlinTest.java | 6 +- .../org/jetbrains/jet/JetLiteFixture.java | 9 +- .../tests/org/jetbrains/jet/JetTestUtils.java | 5 +- .../org/jetbrains/jet/ReadClassDataTest.java | 8 +- .../org/jetbrains/jet/codegen/StdlibTest.java | 17 +- .../jet/compiler/CompileEnvironmentTest.java | 10 +- idea/src/META-INF/plugin.xml | 6 - .../jet/plugin/compiler/JetCompiler.java | 53 ++++++- .../plugin/compiler/JetLibraryManager.java | 105 ------------- .../compiler/PluginCompilerEnvironment.java | 34 ---- .../compiler/WholeProjectAnalyzerFacade.java | 6 - .../jet/shift/NamespaceToPackage.java | 7 +- stdlib/ktSrc/{stdlib/ktSrc => }/Arrays.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/Filter.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/Iterators.kt | 0 .../{stdlib/ktSrc => }/JavaCollections.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/JavaIo.kt | 0 .../ktSrc/{stdlib/ktSrc => }/JavaIterables.kt | 0 .../ktSrc => }/JavaIterablesSpecial.kt | 2 +- stdlib/ktSrc/{stdlib/ktSrc => }/JavaUtil.kt | 0 .../ktSrc/{stdlib/ktSrc => }/JavaUtilMap.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/Standard.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/String.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/System.kt | 0 stdlib/ktSrc/{stdlib/ktSrc => }/Thread.kt | 0 .../generated/ArraysFromJavaCollections.kt | 0 .../generated/ArraysFromJavaIterables.kt | 0 .../JavaUtilIterablesFromJavaCollections.kt | 0 .../generated/StandardFromJavaCollections.kt | 0 .../generated/StandardFromJavaIterables.kt | 0 .../ktSrc => }/modules/ModuleBuilder.kt | 24 +-- stdlib/src/jet/modules/IModuleBuilder.java | 1 - templatelib/templatelib.iml | 2 +- testlib/testlib.iml | 2 +- 43 files changed, 203 insertions(+), 470 deletions(-) rename compiler/backend/src/org/jetbrains/jet/compiler/{AbstractCompileEnvironment.java => CompileEnvironment.java} (87%) delete mode 100644 compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java rename compiler/testData/compiler/smoke/{src => }/Smoke.kt (100%) delete mode 100644 compiler/testData/compiler/smoke/test/SmokeTest.kt delete mode 100644 idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java delete mode 100644 idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java rename stdlib/ktSrc/{stdlib/ktSrc => }/Arrays.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/Filter.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/Iterators.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaCollections.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaIo.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaIterables.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaIterablesSpecial.kt (99%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaUtil.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/JavaUtilMap.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/Standard.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/String.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/System.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/Thread.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/generated/ArraysFromJavaCollections.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/generated/ArraysFromJavaIterables.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/generated/JavaUtilIterablesFromJavaCollections.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/generated/StandardFromJavaCollections.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/generated/StandardFromJavaIterables.kt (100%) rename stdlib/ktSrc/{stdlib/ktSrc => }/modules/ModuleBuilder.kt (77%) diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 7d92d477332..1397a2192d0 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -15,7 +15,6 @@ - diff --git a/build.xml b/build.xml index 8150c68078f..8f7b193af88 100644 --- a/build.xml +++ b/build.xml @@ -3,13 +3,9 @@ - + - - - - @@ -43,23 +39,14 @@ - - - - - - - - - - + - - + + @@ -70,7 +57,6 @@ - @@ -84,32 +70,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java b/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java similarity index 87% rename from compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java rename to compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java index 4d151946178..ae74afa756c 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/AbstractCompileEnvironment.java +++ b/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java @@ -1,16 +1,19 @@ 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.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; @@ -19,6 +22,7 @@ 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; @@ -26,13 +30,74 @@ import java.util.List; import java.util.jar.*; /** - * @author alex.tkachman + * The environment for compiling a bunch of source files or + * + * @author yole */ -public abstract class AbstractCompileEnvironment { - protected Project project; +public class CompileEnvironment { + private JetCoreEnvironment myEnvironment; + private final Disposable myRootDisposable; + private PrintStream myErrorStream = System.out; - protected abstract void addToClasspath(File file); + public CompileEnvironment() { + myRootDisposable = new Disposable() { + @Override + public void dispose() { + } + }; + myEnvironment = new JetCoreEnvironment(myRootDisposable); + } + 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; @@ -99,52 +164,6 @@ public abstract class AbstractCompileEnvironment { 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) { @@ -164,11 +183,11 @@ public abstract class AbstractCompileEnvironment { } public IModuleSetBuilder loadModuleScript(String moduleFile) { - CompileSession scriptCompileSession = new CompileSession(this); + CompileSession scriptCompileSession = new CompileSession(myEnvironment); scriptCompileSession.addSources(moduleFile); scriptCompileSession.addStdLibSources(); - if (!scriptCompileSession.analyze(System.out)) { + if (!scriptCompileSession.analyze(myErrorStream)) { return null; } final ClassFileFactory factory = scriptCompileSession.generate(); @@ -204,22 +223,22 @@ public abstract class AbstractCompileEnvironment { } public ClassFileFactory compileModule(IModuleBuilder moduleBuilder, String directory) { - CompileSession moduleCompileSession = new CompileSession(this); + CompileSession moduleCompileSession = new CompileSession(myEnvironment); moduleCompileSession.addStdLibSources(); for (String sourceFile : moduleBuilder.getSourceFiles()) { moduleCompileSession.addSources(new File(directory, sourceFile).getPath()); } for (String classpathRoot : moduleBuilder.getClasspathRoots()) { - addToClasspath(new File(classpathRoot)); + myEnvironment.addToClasspath(new File(classpathRoot)); } - if (!moduleCompileSession.analyze(System.out)) { + if (!moduleCompileSession.analyze(myErrorStream)) { return null; } return moduleCompileSession.generate(); } private static String getHomeDirectory() { - return new File(PathManager.getResourceRoot(CoreCompileEnvironment.class, "/org/jetbrains/jet/compiler/CoreCompileEnvironment.class")).getParentFile().getParentFile().getParent(); + return new File(PathManager.getResourceRoot(CompileEnvironment.class, "/org/jetbrains/jet/compiler/CompileEnvironment.class")).getParentFile().getParentFile().getParent(); } private static final List sanitized = Arrays.asList("kotlin/", "std/"); @@ -312,11 +331,10 @@ public abstract class AbstractCompileEnvironment { } } - public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime, boolean stdlib) { - CompileSession session = new CompileSession(this); + public void compileBunchOfSources(String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime) { + CompileSession session = new CompileSession(myEnvironment); session.addSources(sourceFileOrDir); - if(!stdlib) - session.addStdLibSources(); + session.addStdLibSources(); String mainClass = null; for (JetNamespace namespace : session.getSourceFileNamespaces()) { @@ -325,7 +343,7 @@ public abstract class AbstractCompileEnvironment { break; } } - if (!session.analyze(System.out)) { + if (!session.analyze(myErrorStream)) { return; } @@ -358,8 +376,4 @@ public abstract class AbstractCompileEnvironment { } } } - - 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 6945c0a8570..9b4a3391cd2 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java +++ b/compiler/backend/src/org/jetbrains/jet/compiler/CompileSession.java @@ -4,12 +4,11 @@ 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; @@ -19,7 +18,6 @@ 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; /** @@ -28,13 +26,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(AbstractCompileEnvironment environment) { + public CompileSession(JetCoreEnvironment environment) { myEnvironment = environment; } @@ -52,32 +50,28 @@ public class CompileSession { return; } - addSources(new File(path), mySourceFileNamespaces); + addSources(new File(path)); } - private void addSources(File file, List namespaces) { + private void addSources(File file) { if(file.isDirectory()) { for (File child : file.listFiles()) { - addSources(child, namespaces); + addSources(child); } } else { VirtualFile fileByPath = myEnvironment.getLocalFileSystem().findFileByPath(file.getAbsolutePath()); PsiFile psiFile = PsiManager.getInstance(myEnvironment.getProject()).findFile(fileByPath); if(psiFile instanceof JetFile) { - namespaces.add(((JetFile) psiFile).getRootNamespace()); + mySourceFileNamespaces.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, namespaces); + addSources(virtualFile); } } else { @@ -90,28 +84,10 @@ 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) { @@ -119,19 +95,18 @@ public class CompileSession { } return false; } - myBindingContext = analyze(); + List allNamespaces = new ArrayList(mySourceFileNamespaces); + allNamespaces.addAll(myLibrarySourceFileNamespaces); + myBindingContext = AnalyzerFacade.analyzeNamespacesWithJavaIntegration( + myEnvironment.getProject(), allNamespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); 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, handler); + generationState.compileCorrectNamespaces(myBindingContext, mySourceFileNamespaces); return generationState.getFactory(); } @@ -142,25 +117,16 @@ public class CompileSession { } public boolean addStdLibSources() { - 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(); + final File unpackedRuntimePath = CompileEnvironment.getUnpackedRuntimePath(); if (unpackedRuntimePath != null) { - addSources(new File(unpackedRuntimePath, "stdlib/ktSrc").getAbsoluteFile(), forAnalize ? myLibrarySourceFileNamespaces : mySourceFileNamespaces); + addSources(new File(unpackedRuntimePath, "../../../stdlib/ktSrc").getAbsoluteFile()); } else { - final File runtimeJarPath = CoreCompileEnvironment.getRuntimeJarPath(); + final File runtimeJarPath = CompileEnvironment.getRuntimeJarPath(); if (runtimeJarPath != null && runtimeJarPath.exists()) { VirtualFile runtimeJar = myEnvironment.getLocalFileSystem().findFileByPath(runtimeJarPath.getAbsolutePath()); VirtualFile jarRoot = myEnvironment.getJarFileSystem().findFileByPath(runtimeJar.getPath() + "!/stdlib/ktSrc"); - addSources(jarRoot, myLibrarySourceFileNamespaces); + addSources(jarRoot); } else { return false; @@ -168,8 +134,4 @@ 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 deleted file mode 100644 index d612ee0764a..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/compiler/CoreCompileEnvironment.java +++ /dev/null @@ -1,84 +0,0 @@ -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 4b82fa150ce..56db85a522d 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java @@ -2,8 +2,7 @@ package org.jetbrains.jet.cli; import com.sampullara.cli.Args; import com.sampullara.cli.Argument; -import org.jetbrains.jet.compiler.AbstractCompileEnvironment; -import org.jetbrains.jet.compiler.CoreCompileEnvironment; +import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.compiler.CompileEnvironmentException; /** @@ -26,8 +25,6 @@ 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) { @@ -42,10 +39,10 @@ public class KotlinCompiler { return; } - CoreCompileEnvironment environment = new CoreCompileEnvironment(); + CompileEnvironment environment = new CompileEnvironment(); try { - environment.setJavaRuntime(AbstractCompileEnvironment.findRtJar(true)); + environment.setJavaRuntime(CompileEnvironment.findRtJar(true)); if (!environment.initializeKotlinRuntime()) { System.out.println("No runtime library found"); return; @@ -56,7 +53,7 @@ public class KotlinCompiler { return; } else { - environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime, arguments.stdlib); + environment.compileBunchOfSources(arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime); } } catch (CompileEnvironmentException e) { System.out.println(e.getMessage()); diff --git a/compiler/testData/compiler/smoke/src/Smoke.kt b/compiler/testData/compiler/smoke/Smoke.kt similarity index 100% rename from compiler/testData/compiler/smoke/src/Smoke.kt rename to compiler/testData/compiler/smoke/Smoke.kt diff --git a/compiler/testData/compiler/smoke/Smoke.kts b/compiler/testData/compiler/smoke/Smoke.kts index 6bebb8d422c..d9429cd1b65 100644 --- a/compiler/testData/compiler/smoke/Smoke.kts +++ b/compiler/testData/compiler/smoke/Smoke.kts @@ -1,7 +1,6 @@ import kotlin.modules.* val modules = module("smoke") { - source files "src/Smoke.kt" - testSource files "test/SmokeTest.kt" + source files "Smoke.kt" jar name System.getProperty("java.io.tmpdir") + "/smoke.jar" } diff --git a/compiler/testData/compiler/smoke/test/SmokeTest.kt b/compiler/testData/compiler/smoke/test/SmokeTest.kt deleted file mode 100644 index 8f5a1b26fef..00000000000 --- a/compiler/testData/compiler/smoke/test/SmokeTest.kt +++ /dev/null @@ -1,9 +0,0 @@ -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 377d79664a2..8bb9e576bc6 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.CoreCompileEnvironment; +import org.jetbrains.jet.compiler.CompileEnvironment; 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 CoreCompileEnvironment jetCoreEnvironment; + private JetCoreEnvironment jetCoreEnvironment; private File tmpdir; public CompileJavaAgainstKotlinTest(File ktFile) { @@ -80,7 +80,7 @@ public class CompileJavaAgainstKotlinTest extends UsefulTestCase { ClassFileFactory classFileFactory = state.getFactory(); - CoreCompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); + CompileEnvironment.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 6520cf84a09..9ff4e21f148 100644 --- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -14,8 +14,7 @@ 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.AbstractCompileEnvironment; -import org.jetbrains.jet.compiler.CoreCompileEnvironment; +import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.plugin.JetLanguage; @@ -29,7 +28,7 @@ public abstract class JetLiteFixture extends UsefulTestCase { @NonNls protected final String myFullDataPath; protected JetFile myFile; - protected CoreCompileEnvironment myEnvironment; + protected JetCoreEnvironment myEnvironment; public JetLiteFixture(@NonNls String dataPath) { myFullDataPath = getTestDataPath() + "/" + dataPath; @@ -58,8 +57,8 @@ public abstract class JetLiteFixture extends UsefulTestCase { } protected void createEnvironmentWithFullJdk() { - myEnvironment = new CoreCompileEnvironment(new JetCoreEnvironment(getTestRootDisposable())); - final File rtJar = AbstractCompileEnvironment.findRtJar(true); + myEnvironment = new JetCoreEnvironment(getTestRootDisposable()); + final File rtJar = CompileEnvironment.findRtJar(true); myEnvironment.addToClasspath(rtJar); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 636c2edf393..14f979b6bc2 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -3,7 +3,6 @@ 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; @@ -138,12 +137,12 @@ public class JetTestUtils { } - public static CoreCompileEnvironment createEnvironmentWithMockJdk(Disposable disposable) { + public static JetCoreEnvironment 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 new CoreCompileEnvironment(environment); + return environment; } diff --git a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java index ed19afcd79b..ce995896f61 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.CoreCompileEnvironment; +import org.jetbrains.jet.compiler.CompileEnvironment; 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 CoreCompileEnvironment jetCoreEnvironment; + private JetCoreEnvironment jetCoreEnvironment; private File tmpdir; private final File testFile; @@ -72,7 +72,7 @@ public class ReadClassDataTest extends UsefulTestCase { } private void createMockCoreEnvironment() { - jetCoreEnvironment = new CoreCompileEnvironment(new JetCoreEnvironment(myTestRootDisposable)); + jetCoreEnvironment = 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(); - CoreCompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath()); + CompileEnvironment.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 24b8a0d10af..6c26a8833ee 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java @@ -1,7 +1,20 @@ package org.jetbrains.jet.codegen; -import org.jetbrains.jet.compiler.CoreCompileEnvironment; +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.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 @@ -33,7 +46,7 @@ public class StdlibTest extends CodegenTestCase { protected ClassFileFactory generateClassesInFile() { try { CompileSession session = new CompileSession(myEnvironment); - CoreCompileEnvironment.initializeKotlinRuntime(myEnvironment); + CompileEnvironment.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 2a58a8e8902..520dee18d48 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 CoreCompileEnvironment environment; + private CompileEnvironment environment; protected void setUp() throws Exception { super.setUp(); - environment = new CoreCompileEnvironment(); + environment = new CompileEnvironment(); } @Override @@ -33,7 +33,7 @@ public class CompileEnvironmentTest extends TestCase { } public void testSmoke() throws IOException { - final File activeRtJar = AbstractCompileEnvironment.findRtJar(true); + final File activeRtJar = CompileEnvironment.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(); - CoreCompileEnvironment.writeToJar(factory, baos, null, false); + CompileEnvironment.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/src/Smoke.kt", "-output", tempFile.getAbsolutePath()).toArray(new String[0])); + KotlinCompiler.main(Arrays.asList("-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/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 a5c8de70651..6fd690eba51 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -13,12 +13,6 @@ - - - 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 fa7c6f761c8..766868d3fc8 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java @@ -17,7 +17,6 @@ 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; @@ -28,7 +27,6 @@ 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; @@ -67,12 +65,19 @@ public class JetCompiler implements TranslatingCompiler { ApplicationManager.getApplication().runReadAction(new Runnable() { @Override public void run() { - PluginCompilerEnvironment compilerEnvironment = new PluginCompilerEnvironment(compileContext.getProject()); - CompileSession compileSession = new CompileSession(compilerEnvironment); - compileSession.addSources(compileContext.getCompileScope().getFiles(null, true)); - compileSession.addStdLibSources(); + VirtualFile[] allFiles = compileContext.getCompileScope().getFiles(null, true); - BindingContext bindingContext = compileSession.analyze(); + 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); boolean errors = false; for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { @@ -91,7 +96,7 @@ public class JetCompiler implements TranslatingCompiler { } if (!errors) { - final ClassFileFactory factory = compileSession.generate(new CompilationErrorHandler() { + generationState.compileCorrectNamespaces(bindingContext, namespaces, new CompilationErrorHandler() { @Override public void reportException(Throwable exception, String fileUrl) { if(exception instanceof CompilationException) { @@ -102,7 +107,22 @@ 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); @@ -115,6 +135,23 @@ 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 deleted file mode 100644 index 95bb78171da..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/compiler/JetLibraryManager.java +++ /dev/null @@ -1,105 +0,0 @@ -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 deleted file mode 100644 index 253ed52c8fb..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/compiler/PluginCompilerEnvironment.java +++ /dev/null @@ -1,34 +0,0 @@ -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 0bfddc50a8c..b858df279df 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/WholeProjectAnalyzerFacade.java @@ -11,7 +11,6 @@ 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; @@ -41,11 +40,6 @@ 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 b8f4d1b96cb..a8cb46e5e83 100644 --- a/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java +++ b/shift/src/org/jetbrains/jet/shift/NamespaceToPackage.java @@ -7,8 +7,7 @@ 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.AbstractCompileEnvironment; -import org.jetbrains.jet.compiler.CoreCompileEnvironment; +import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespace; import org.jetbrains.jet.lang.psi.JetPsiFactory; @@ -62,9 +61,9 @@ public class NamespaceToPackage { } }); - CoreCompileEnvironment compileEnvironment = new CoreCompileEnvironment(); + CompileEnvironment compileEnvironment = new CompileEnvironment(); - compileEnvironment.setJavaRuntime(AbstractCompileEnvironment.findRtJar(true)); + compileEnvironment.setJavaRuntime(CompileEnvironment.findRtJar(true)); if (!compileEnvironment.initializeKotlinRuntime()) { System.out.println("foo"); } diff --git a/stdlib/ktSrc/stdlib/ktSrc/Arrays.kt b/stdlib/ktSrc/Arrays.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/Arrays.kt rename to stdlib/ktSrc/Arrays.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/Filter.kt b/stdlib/ktSrc/Filter.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/Filter.kt rename to stdlib/ktSrc/Filter.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/Iterators.kt b/stdlib/ktSrc/Iterators.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/Iterators.kt rename to stdlib/ktSrc/Iterators.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaCollections.kt b/stdlib/ktSrc/JavaCollections.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/JavaCollections.kt rename to stdlib/ktSrc/JavaCollections.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaIo.kt b/stdlib/ktSrc/JavaIo.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/JavaIo.kt rename to stdlib/ktSrc/JavaIo.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaIterables.kt b/stdlib/ktSrc/JavaIterables.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/JavaIterables.kt rename to stdlib/ktSrc/JavaIterables.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaIterablesSpecial.kt b/stdlib/ktSrc/JavaIterablesSpecial.kt similarity index 99% rename from stdlib/ktSrc/stdlib/ktSrc/JavaIterablesSpecial.kt rename to stdlib/ktSrc/JavaIterablesSpecial.kt index 2e30749f216..3a564fabeb8 100644 --- a/stdlib/ktSrc/stdlib/ktSrc/JavaIterablesSpecial.kt +++ b/stdlib/ktSrc/JavaIterablesSpecial.kt @@ -82,4 +82,4 @@ fun java.lang.Iterable.contains(item : T) : Boolean { } return false -} \ No newline at end of file +} diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaUtil.kt b/stdlib/ktSrc/JavaUtil.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/JavaUtil.kt rename to stdlib/ktSrc/JavaUtil.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/JavaUtilMap.kt b/stdlib/ktSrc/JavaUtilMap.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/JavaUtilMap.kt rename to stdlib/ktSrc/JavaUtilMap.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/Standard.kt b/stdlib/ktSrc/Standard.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/Standard.kt rename to stdlib/ktSrc/Standard.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/String.kt b/stdlib/ktSrc/String.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/String.kt rename to stdlib/ktSrc/String.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/System.kt b/stdlib/ktSrc/System.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/System.kt rename to stdlib/ktSrc/System.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/Thread.kt b/stdlib/ktSrc/Thread.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/Thread.kt rename to stdlib/ktSrc/Thread.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt b/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaCollections.kt rename to stdlib/ktSrc/generated/ArraysFromJavaCollections.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt b/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/generated/ArraysFromJavaIterables.kt rename to stdlib/ktSrc/generated/ArraysFromJavaIterables.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt b/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt rename to stdlib/ktSrc/generated/JavaUtilIterablesFromJavaCollections.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaCollections.kt b/stdlib/ktSrc/generated/StandardFromJavaCollections.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaCollections.kt rename to stdlib/ktSrc/generated/StandardFromJavaCollections.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaIterables.kt b/stdlib/ktSrc/generated/StandardFromJavaIterables.kt similarity index 100% rename from stdlib/ktSrc/stdlib/ktSrc/generated/StandardFromJavaIterables.kt rename to stdlib/ktSrc/generated/StandardFromJavaIterables.kt diff --git a/stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt b/stdlib/ktSrc/modules/ModuleBuilder.kt similarity index 77% rename from stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt rename to stdlib/ktSrc/modules/ModuleBuilder.kt index fb03beb7448..d0f2985880a 100644 --- a/stdlib/ktSrc/stdlib/ktSrc/modules/ModuleBuilder.kt +++ b/stdlib/ktSrc/modules/ModuleBuilder.kt @@ -21,13 +21,9 @@ class ModuleSetBuilder(): IModuleSetBuilder { override fun getModules(): List? = modules } -class SourcesBuilder() { - protected val sourceFiles: ArrayList = ArrayList() - - fun files(vararg pattern: String) { - for(p in pattern) { - sourceFiles.add(p) - } +class SourcesBuilder(val parent: ModuleBuilder) { + fun files(pattern: String) { + parent.addSourceFiles(pattern) } } @@ -44,18 +40,23 @@ class JarBuilder(val parent: ModuleBuilder) { } open class ModuleBuilder(val name: String): IModuleBuilder { - val source = SourcesBuilder() - val testSource = SourcesBuilder() - + val sourceFiles: ArrayList = ArrayList() 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) } @@ -64,8 +65,7 @@ open class ModuleBuilder(val name: String): IModuleBuilder { _jarName = name } - override fun getSourceFiles(): List? = source.sourceFiles - override fun getTestSourceFiles(): List? = testSource.sourceFiles + override fun getSourceFiles(): List? = 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 419bdd9c44f..f455eb5fabc 100644 --- a/stdlib/src/jet/modules/IModuleBuilder.java +++ b/stdlib/src/jet/modules/IModuleBuilder.java @@ -8,7 +8,6 @@ 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 14ccb779e04..148c33735b9 100644 --- a/templatelib/templatelib.iml +++ b/templatelib/templatelib.iml @@ -8,8 +8,8 @@ + - diff --git a/testlib/testlib.iml b/testlib/testlib.iml index 17a8df813fb..d1780f417e7 100644 --- a/testlib/testlib.iml +++ b/testlib/testlib.iml @@ -17,7 +17,7 @@ - +