From 3e3a22a5c92dbda5572e6f78eff5c12b4f5c728b Mon Sep 17 00:00:00 2001
From: pTalanov <Pavel.Talanov@jetbrains.com>
Date: Fri, 4 May 2012 16:23:31 +0400
Subject: [PATCH] CLI refactoring. Some steps towards nice K2JS cli.

---
 .../jetbrains/jet/cli/common/CLICompiler.java | 18 +++++---
 .../messages/PrintingMessageCollector.java    | 11 ++++-
 .../jetbrains/jet/cli/js/K2JSCompiler.java    | 44 +++++++++----------
 .../jet/cli/js/K2JSCompilerArguments.java     |  4 +-
 .../jetbrains/jet/cli/jvm/K2JVMCompiler.java  | 17 +++----
 .../jet/plugin/compiler/K2JSCompiler.java     | 13 ++++--
 .../src/org/jetbrains/k2js/config/Config.java | 12 +++++
 7 files changed, 72 insertions(+), 47 deletions(-)

diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java
index 88dc62ee16c..0122c3511c3 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java
@@ -16,12 +16,13 @@
 
 package org.jetbrains.jet.cli.common;
 
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.util.Disposer;
 import com.sampullara.cli.Args;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation;
-import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
-import org.jetbrains.jet.cli.common.messages.MessageRenderer;
+import org.jetbrains.jet.cli.common.messages.*;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException;
+import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 
 import java.io.PrintStream;
 import java.util.List;
@@ -107,20 +108,25 @@ public abstract class CLICompiler<A extends CompilerArguments, C extends Compile
         final MessageRenderer messageRenderer = getMessageRenderer(arguments);
         errStream.print(messageRenderer.renderPreamble());
         printVersionIfNeeded(errStream, arguments, messageRenderer);
+        PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, true);
+        Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
         try {
-            return doExecute(errStream, arguments, messageRenderer);
+            return doExecute(arguments, messageCollector, rootDisposable);
         }
         finally {
+            messageCollector.printToErrStream();
             errStream.print(messageRenderer.renderConclusion());
+            Disposer.dispose(rootDisposable);
         }
     }
 
     //TODO: can't declare parameters as not null due to KT-1863
     @NotNull
-    protected abstract ExitCode doExecute(PrintStream stream, A arguments, MessageRenderer renderer);
+    protected abstract ExitCode doExecute(A arguments, PrintingMessageCollector messageCollector, Disposable rootDisposable);
 
+    //TODO: can we make it private?
     @NotNull
-    private MessageRenderer getMessageRenderer(@NotNull A arguments) {
+    protected MessageRenderer getMessageRenderer(@NotNull A arguments) {
         return arguments.isTags() ? MessageRenderer.TAGS : MessageRenderer.PLAIN;
     }
 
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java
index 9f9e8b0120d..a5dbe3644c7 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java
@@ -31,7 +31,8 @@ import java.util.Collection;
  * @author Pavel Talanov
  */
 public class PrintingMessageCollector implements MessageCollector {
-    private final boolean verbose;
+
+    private boolean verbose;
     private final PrintStream errStream;
     private final MessageRenderer messageRenderer;
 
@@ -70,4 +71,12 @@ public class PrintingMessageCollector implements MessageCollector {
             }
         }
     }
+
+    public boolean isVerbose() {
+        return verbose;
+    }
+
+    public void setVerbose(boolean verbose) {
+        this.verbose = verbose;
+    }
 }
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java
index c88a483958c..74817ba255d 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java
@@ -24,20 +24,15 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.common.CLICompiler;
 import org.jetbrains.jet.cli.common.ExitCode;
-import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport;
-import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
-import org.jetbrains.jet.cli.common.messages.MessageRenderer;
-import org.jetbrains.jet.cli.common.messages.PrintingMessageCollector;
-import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
+import org.jetbrains.jet.cli.common.messages.*;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS;
 import org.jetbrains.k2js.config.Config;
+import org.jetbrains.k2js.facade.K2JSTranslator;
 
-import java.io.PrintStream;
-import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.jet.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
@@ -60,39 +55,42 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments, K2JSCompile
 
     @NotNull
     @Override
-    protected ExitCode doExecute(PrintStream stream, K2JSCompilerArguments arguments, MessageRenderer renderer) {
-        PrintingMessageCollector messageCollector = new PrintingMessageCollector(stream, renderer, true);
-        if (arguments.module != null) {
-            stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Module arg is not supported", NO_LOCATION));
-            return ExitCode.INTERNAL_ERROR;
-        }
+    protected ExitCode doExecute(K2JSCompilerArguments arguments, PrintingMessageCollector messageCollector, Disposable rootDisposable) {
 
         if (arguments.srcdir == null) {
-            stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Specify sources location via -srcdir", NO_LOCATION));
+            messageCollector.report(CompilerMessageSeverity.ERROR, "Specify sources location via -srcdir", NO_LOCATION);
             return ExitCode.INTERNAL_ERROR;
         }
 
-        Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
         final JetCoreEnvironment environmentForJS = JetCoreEnvironment.getCoreEnvironmentForJS(rootDisposable);
         environmentForJS.addSources(arguments.srcdir);
         AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(messageCollector);
         final List<JetFile> sources = environmentForJS.getSourceFiles();
+        final Config config = Config.getEmptyConfig(environmentForJS.getProject());
         analyzerWithCompilerReport.analyzeAndReport(new Function0<AnalyzeExhaust>() {
             @Override
             public AnalyzeExhaust invoke() {
                 BindingContext context = AnalyzerFacadeForJS
-                        .analyzeFiles(sources, Predicates.<PsiFile>alwaysTrue(), new Config(environmentForJS.getProject()) {
-                            @NotNull
-                            @Override
-                            protected List<JetFile> generateLibFiles() {
-                                return Collections.emptyList();
-                            }
-                        });
+                        .analyzeFiles(sources, Predicates.<PsiFile>alwaysTrue(), config);
                 return AnalyzeExhaust.success(context, JetStandardLibrary.getInstance());
             }
         }, sources);
+        if (analyzerWithCompilerReport.hasErrors()) {
 
-        stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Greeting", NO_LOCATION));
+            return ExitCode.COMPILATION_ERROR;
+        }
+
+        if (arguments.outputDir != null) {
+            try {
+                K2JSTranslator.translateWithCallToMainAndSaveToFile(environmentForJS.getSourceFiles(), arguments.outputDir, config, environmentForJS.getProject());
+            }
+            catch (Exception e) {
+                return ExitCode.INTERNAL_ERROR;
+            }
+        } else {
+            messageCollector.report(CompilerMessageSeverity.ERROR, "Specify output directory via -output", CompilerMessageLocation.NO_LOCATION);
+            return ExitCode.INTERNAL_ERROR;
+        }
         return ExitCode.OK;
     }
 }
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java
index 75f0855d864..b73666952c5 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java
@@ -26,8 +26,8 @@ public class K2JSCompilerArguments extends CompilerArguments {
     @Argument(value = "output", description = "Output directory")
     public String outputDir;
 
-    @Argument(value = "module", description = "Module to compile")
-    public String module;
+    @Argument(value = "libzip", description = "Path to zipped lib sources")
+    public String libzip;
 
     @Argument(value = "srcdir", description = "Sources directory")
     public String srcdir;
diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java
index 6cf5b743e6a..b7d2a4b8935 100644
--- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java
+++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java
@@ -19,7 +19,6 @@ package org.jetbrains.jet.cli.jvm;
 import com.google.common.base.Splitter;
 import com.google.common.collect.Iterables;
 import com.intellij.openapi.Disposable;
-import com.intellij.openapi.util.Disposer;
 import jet.modules.Module;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.common.CLICompiler;
@@ -53,9 +52,7 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments, K2JVMComp
 
     @Override
     @NotNull
-    protected ExitCode doExecute(PrintStream errStream,
-            K2JVMCompilerArguments arguments,
-            MessageRenderer messageRenderer) {
+    protected ExitCode doExecute(K2JVMCompilerArguments arguments, PrintingMessageCollector messageCollector, Disposable rootDisposable) {
 
         CompilerSpecialMode mode = parseCompilerSpecialMode(arguments);
         File jdkHeadersJar;
@@ -85,9 +82,6 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments, K2JVMComp
         }
 
         CompilerDependencies dependencies = new CompilerDependencies(mode, CompilerDependencies.findRtJar(), jdkHeadersJar, runtimeJar);
-        PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, arguments.verbose);
-        Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
-
         JetCoreEnvironment environment = JetCoreEnvironment.getCoreEnvironmentForJVM(rootDisposable, dependencies);
         K2JVMCompileEnvironmentConfiguration configuration =
                 new K2JVMCompileEnvironmentConfiguration(environment, messageCollector);
@@ -99,8 +93,11 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments, K2JVMComp
 
             boolean noErrors;
             if (arguments.module != null) {
+                boolean oldVerbose = messageCollector.isVerbose();
+                messageCollector.setVerbose(false);
                 List<Module> modules = CompileEnvironmentUtil
-                        .loadModuleScript(arguments.module, new PrintingMessageCollector(errStream, messageRenderer, false));
+                        .loadModuleScript(arguments.module, messageCollector);
+                messageCollector.setVerbose(oldVerbose);
                 File directory = new File(arguments.module).getParentFile();
                 noErrors = KotlinToJVMBytecodeCompiler.compileModules(configuration, modules,
                                                                       directory, arguments.jar, arguments.outputDir,
@@ -132,10 +129,6 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments, K2JVMComp
                                     CompilerMessageLocation.NO_LOCATION);
             return INTERNAL_ERROR;
         }
-        finally {
-            Disposer.dispose(rootDisposable);
-            messageCollector.printToErrStream();
-        }
     }
 
     @NotNull
diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java b/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java
index d85b92f8fa4..001f88398ea 100644
--- a/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java
+++ b/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java
@@ -86,19 +86,26 @@ public final class K2JSCompiler implements TranslatingCompiler {
         try {
             VirtualFile[] roots = ModuleRootManager.getInstance(module).getSourceRoots();
             if (roots.length != 1) {
-                context.addMessage(CompilerMessageCategory.ERROR, "K2JSCompiler does not support module source roots.", null, -1, -1);
+                context.addMessage(CompilerMessageCategory.ERROR, "K2JSCompiler does not support multiple module source roots.", null, -1,
+                                   -1);
                 return -1;
             }
-            String[] commandLineArgs = {"-tags", "-verbose", "-version", "-srcdir", roots[0].getPath()};
+            String[] commandLineArgs = constructArguments(context.getModuleOutputDirectory(module), roots[0]);
             Object rc = invokeExecMethod(environment, out, context, commandLineArgs, "org.jetbrains.jet.cli.js.K2JSCompiler");
             return CompilerUtils.getReturnCodeFromObject(rc);
         }
         catch (Throwable e) {
-            context.addMessage(CompilerMessageCategory.ERROR, "Fail!", null, -1, -1);
+             context.addMessage(CompilerMessageCategory.ERROR, "Exception while executing: " + e.getMessage(), null, -1, -1);
         }
         return -1;
     }
 
+    private static String[] constructArguments(@NotNull VirtualFile outDir, @NotNull VirtualFile srcDir) {
+        String srcPath = srcDir.getPath();
+        String outPath = outDir.getPath();
+        return new String[] {"-tags", "-verbose", "-version", "-srcdir", srcPath, "-output", outPath};
+    }
+
     @NotNull
     @Override
     public String getDescription() {
diff --git a/js/js.translator/src/org/jetbrains/k2js/config/Config.java b/js/js.translator/src/org/jetbrains/k2js/config/Config.java
index 1d182c5d729..ae3b12449be 100644
--- a/js/js.translator/src/org/jetbrains/k2js/config/Config.java
+++ b/js/js.translator/src/org/jetbrains/k2js/config/Config.java
@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetFile;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -31,6 +32,17 @@ import java.util.List;
  */
 public abstract class Config {
 
+    @NotNull
+    public static Config getEmptyConfig(@NotNull Project project) {
+        return new Config(project) {
+            @NotNull
+            @Override
+            protected List<JetFile> generateLibFiles() {
+                return Collections.emptyList();
+            }
+        };
+    }
+
     @NotNull
     protected static final List<String> LIB_FILE_NAMES = Arrays.asList(
         "/core/annotations.kt",