Remove dartc optimizing backend.

dart/compiler/java/com/google/dart/runner/DartRunner.java

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 package com.google.dart.runner;
 
 import com.google.common.base.Joiner;
 import com.google.common.collect.Lists;
 import com.google.common.io.CharStreams;
 import com.google.common.io.Files;
 import com.google.dart.compiler.Backend;
 import com.google.dart.compiler.CommandLineOptions;
 import com.google.dart.compiler.CommandLineOptions.DartRunnerOptions;
 import com.google.dart.compiler.CompilerConfiguration;
 import com.google.dart.compiler.DartArtifactProvider;
 import com.google.dart.compiler.DartCompiler;
 import com.google.dart.compiler.DartCompilerListener;
 import com.google.dart.compiler.DefaultCompilerConfiguration;
 import com.google.dart.compiler.DefaultDartCompilerListener;
 import com.google.dart.compiler.LibrarySource;
 import com.google.dart.compiler.Source;
 import com.google.dart.compiler.UnitTestBatchRunner;
 import com.google.dart.compiler.UnitTestBatchRunner.Invocation;
 import com.google.dart.compiler.UrlLibrarySource;
-import com.google.dart.compiler.backend.js.ClosureJsBackend;
 import com.google.dart.compiler.backend.js.JavascriptBackend;
-import com.google.debugging.sourcemap.SourceMapConsumerFactory;
-import com.google.debugging.sourcemap.SourceMapParseException;
-import com.google.debugging.sourcemap.SourceMapSupplier;
-import com.google.debugging.sourcemap.SourceMapping;
 
 import org.kohsuke.args4j.CmdLineException;
 import org.kohsuke.args4j.CmdLineParser;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.Reader;
@@ skipping 78 matching lines @@
     String script = options.getSourceFiles().get(0);
     ArrayList<String> scriptArguments = new ArrayList<String>();
 
     LibrarySource app = new UrlLibrarySource(new File(script));
 
     File outFile =  options.getOutputFilename();
 
     DefaultDartCompilerListener listener =
         new DefaultDartCompilerListener(stderr, options.printErrorFormat());
 
-    CompilationResult compiled;
+    String compiled;
     compiled = compileApp(app, imports, options, listener);
 
     if (listener.getErrorCount() != 0) {
       throw new RunnerError("Compilation failed.");
     }
 
     if (outFile != null) {
       File dir = outFile.getParentFile();
       if (dir != null) {
         if (!dir.exists()) {
           throw new RunnerError("Cannot create: " + outFile.getName()
                                 + ".  " + dir + " does not exist");
         }
         if (!dir.canWrite()) {
           throw new RunnerError("Cannot write " + outFile.getName() + " to "
               + dir + ":  Permission denied.");
         }
       } else {
         dir = new File (".");
         if (!dir.canWrite()) {
           throw new RunnerError("Cannot write " + outFile.getName() + " to "
               + dir + ":  Permission denied.");
         }
       }
       try {
-        Files.write(compiled.js, outFile, Charset.defaultCharset());
+        Files.write(compiled, outFile, Charset.defaultCharset());
       } catch (IOException e) {
         throw new RunnerError(e);
       }
     }
 
     if (!options.shouldCompileOnly() && !options.checkOnly()) {
       runApp(compiled, app.getName(), options, scriptArguments.toArray(new String[0]),
              stdout, stderr);
     }
   }
@@ skipping 68 matching lines @@
   }
 
   public static void compileAndRunApp(LibrarySource app,
                                       DartRunnerOptions options,
                                       CompilerConfiguration config,
                                       DartCompilerListener listener,
                                       String[] dartArguments,
                                       PrintStream stdout,
                                       PrintStream stderr)
       throws RunnerError {
-    CompilationResult compiled = compileApp(
+    String compiled = compileApp(
         app,  options, Collections.<LibrarySource>emptyList(), config, listener);
     runApp(compiled, app.getName(), options, dartArguments, stdout, stderr);
   }
 
-  private static void runApp(CompilationResult compiled,
+  private static void runApp(String compiled,
                              String sourceName,
                              DartRunnerOptions options,
                              String[] scriptArguments,
                              PrintStream stdout,
                              PrintStream stderr)
       throws RunnerError {
 
-    if (options.useRhino()) {
-      new RhinoLauncher().execute(compiled.js, sourceName, scriptArguments, options, stdout, stderr);
-    } else {
-      new V8Launcher(compiled.mapping).execute(compiled.js, sourceName, scriptArguments, options,
-                                               stdout, stderr);
-    }
+    new V8Launcher().execute(compiled, sourceName, scriptArguments, options,
+                               stdout, stderr);
   }
 
-  private static class CompilationResult {
-    final SourceMapping mapping;
-    final String js;
-
-    public CompilationResult(String js, SourceMapping mapping) {
-      this.mapping = mapping;
-      this.js = js;
-    }
-  }
-
-  private static CompilationResult compileApp (LibrarySource app, List<LibrarySource> imports,
+  private static String compileApp (LibrarySource app, List<LibrarySource> imports,
       final DartRunnerOptions options, DartCompilerListener listener) throws RunnerError {
-    Backend backend;
-    if (options.shouldOptimize()) {
-      backend = new ClosureJsBackend(
-          options.developerModeChecks(),
-          options.generateHumanReadableOutput());
-    } else {
-      backend = new JavascriptBackend();
-    }
+    Backend backend = new JavascriptBackend();
     CompilerConfiguration config = new DefaultCompilerConfiguration(backend, options) {
       @Override
       public boolean expectEntryPoint() {
         return true;
       }
 
       @Override
       public boolean typeErrorsAreFatal() {
         return options.typeErrorsAreFatal();
       }
     };
     return compileApp(app, options, imports, config, listener);
   }
 
   /**
    * Parses and compiles an application to Javascript.
    */
-  private static CompilationResult compileApp(LibrarySource app,
-                                              final DartRunnerOptions options,
-                                              List<LibrarySource> imports,
-                                              CompilerConfiguration config,
-                                              DartCompilerListener listener)  throws RunnerError {
+  private static String compileApp(LibrarySource app,
+                                   final DartRunnerOptions options,
+                                   List<LibrarySource> imports,
+                                   CompilerConfiguration config,
+                                   DartCompilerListener listener)  throws RunnerError {
     try {
       final RunnerDartArtifactProvider provider = new RunnerDartArtifactProvider();
       String errmsg = DartCompiler.compileLib(app, imports, config, provider, listener);
       if (errmsg != null) {
          throw new RunnerError(errmsg);
       }
       Backend backend = config.getBackends().get(0);
 
-      SourceMapping mapping = null;
-      if (config.getCompilerOptions().generateSourceMaps()) {
-        Reader mr = provider.getArtifactReader(app, "", backend.getSourceMapExtension());
-        if (mr != null) {
-          try {
-            String mapContents = CharStreams.toString(mr);
-            mapping = SourceMapConsumerFactory.parse(mapContents, new SourceMapSupplier() {
-
-              @Override
-              public String getSourceMap(String url) {
-                String contents = provider.getGeneratedFileContents(url);
-                if (contents == null || contents.isEmpty()) {
-                  return null;
-                }
-                return contents;
-              }
-
-            });
-          } catch (SourceMapParseException e) {
-            throw new AssertionError(e);
-          } finally {
-            mr.close();
-          }
-        }
-      }
-
       if (!options.checkOnly()) {
         Reader r = provider.getArtifactReader(app, "", backend.getAppExtension());
         String js = CharStreams.toString(r);
         r.close();
-        return new CompilationResult(js, mapping);
+        return js;
       }
       return null;
     } catch (IOException e) {
       // This can't happen; it's just a StringWriter.
       throw new AssertionError(e);
     }
   }
 }