Removes dartc reliance on its own libraries, now can be targeted at any implementation's libraries

compiler/java/com/google/dart/compiler/DartCompiler.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.compiler;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Sets.SetView;
 import com.google.common.io.CharStreams;
@@ skipping 113 matching lines @@
   }
 
   private static class Compiler {
     private final LibrarySource app;
     private final List<LibrarySource> embeddedLibraries = new ArrayList<LibrarySource>();
     private final DartCompilerMainContext context;
     private final CompilerConfiguration config;
     private final Map<URI, LibraryUnit> libraries = new LinkedHashMap<URI, LibraryUnit>();
     private CoreTypeProvider typeProvider;
     private final boolean incremental;
-    private final boolean usePrecompiledDartLibs;
     private final List<DartCompilationPhase> phases;
     private final LibrarySource coreLibrarySource;
 
     private Compiler(LibrarySource app, List<LibrarySource> embedded, CompilerConfiguration config,
         DartCompilerMainContext context) {
       this.app = app;
       this.config = config;
       this.phases = config.getPhases();
       this.context = context;
       for (LibrarySource library : embedded) {
         if (SystemLibraryManager.isDartSpec(library.getName())) {
           embeddedLibraries.add(context.getSystemLibraryFor(library.getName()));
         } else {
           embeddedLibraries.add(library);
         }
       }
       coreLibrarySource = context.getSystemLibraryFor(CORELIB_URL_SPEC);
       embeddedLibraries.add(coreLibrarySource);
 
       incremental = config.incremental();
-      usePrecompiledDartLibs = true;
     }
-    
+
     void addResolvedLibraries(Map<URI, LibraryUnit> resolvedLibraries) {
       libraries.putAll(resolvedLibraries);
     }
-    
+
     Map<URI, LibraryUnit> getLibraries() {
       return libraries;
     }
 
     private void compile() {
       TraceEvent logEvent = Tracer.canTrace() ? Tracer.start(DartEventType.COMPILE) : null;
       try {
         updateAndResolve();
         if (!config.resolveDespiteParseErrors() && context.getErrorCount() > 0) {
           return;
@@ skipping 75 matching lines @@
 
             // Prepare DartSource for "#source" unit.
             final DartSource dartSrc = libSrc.getSourceFor(relPath);
             if (dartSrc == null || !dartSrc.exists()) {
               // Dart Editor needs to have all missing files reported as compilation errors.
               reportMissingSource(context, libSrc, libNode);
               continue;
             }
 
             if (!incremental
-                || (libIsDartUri && !usePrecompiledDartLibs)
+                || libIsDartUri
                 || isSourceOutOfDate(dartSrc)) {
               DartUnit unit = parse(dartSrc, lib.getPrefixes(),  false);
 
               // If we just parsed unit of library, report problems with its "#import" declarations.
               if (libNode == selfSourcePath) {
                 for (LibraryNode importPathNode : lib.getImportPaths()) {
                   LibrarySource dep = getImportSource(libSrc, importPathNode);
                   if (dep == null) {
                     reportMissingSource(context, libSrc, importPathNode);
                   }
@@ skipping 576 matching lines @@
       event.setSource(libSrc);
       context.onError(event);
     }
     CoreTypeProvider getTypeProvider() {
       typeProvider.getClass(); // Quick null check.
       return typeProvider;
     }
   }
 
   /**
-   * Selectively compile a library. Use supplied libraries and ASTs when available. 
-   * This allows programming tools to provide customized ASTs for code that is currently being 
+   * Selectively compile a library. Use supplied libraries and ASTs when available.
+   * This allows programming tools to provide customized ASTs for code that is currently being
    * edited, and may not compile correctly.
    */
   private static class SelectiveCompiler extends Compiler {
     /** Map from source URI to AST representing the source */
     private final Map<URI, LibraryUnit> resolvedLibraries;
     private final Map<URI,DartUnit> parsedUnits;
     private Collection<LibraryUnit> librariesToProcess;
 
     private SelectiveCompiler(LibrarySource app, Map<URI, LibraryUnit> resolvedLibraries,
-        Map<URI,DartUnit> parsedUnits, CompilerConfiguration config, 
+        Map<URI,DartUnit> parsedUnits, CompilerConfiguration config,
         DartCompilerMainContext context) {
       super(app, Collections.<LibrarySource>emptyList(), config, context);
       this.resolvedLibraries = resolvedLibraries;
       this.parsedUnits = parsedUnits;
       addResolvedLibraries(resolvedLibraries);
     }
-    
+
     @Override
     Collection<LibraryUnit> getLibrariesToProcess() {
       if (librariesToProcess == null) {
         librariesToProcess = new ArrayList<LibraryUnit>();
         librariesToProcess.addAll(super.getLibrariesToProcess());
         librariesToProcess.removeAll(resolvedLibraries.values());
       }
       return librariesToProcess;
     }
 
@@ skipping 21 matching lines @@
     } catch (CmdLineException e) {
       System.err.println(e.getLocalizedMessage());
       showUsage(cmdLineParser, System.err);
       System.exit(1);
     }
 
     assert compilerOptions != null;
     return compilerOptions;
   }
 
-  public static void main(String[] args) {
+  public static void main(final String[] topArgs) {
     Tracer.init();
 
-    CompilerOptions topCompilerOptions = processCommandLineOptions(args);
+    CompilerOptions topCompilerOptions = processCommandLineOptions(topArgs);
     boolean result = false;
     try {
       if (topCompilerOptions.shouldBatch()) {
-        if (args.length > 1) {
+        if (topArgs.length > 1) {
           System.err.println("(Extra arguments specified with -batch ignored.)");
         }
-        UnitTestBatchRunner.runAsBatch(args, new Invocation() {
+        UnitTestBatchRunner.runAsBatch(topArgs, new Invocation() {
           @Override
-          public boolean invoke(String[] args) throws Throwable {
-            CompilerOptions compilerOptions = processCommandLineOptions(args);
+          public boolean invoke(String[] lineArgs) throws Throwable {
+            List<String> allArgs = new ArrayList<String>();
+            for (String arg: topArgs) {
+              if (!arg.equals("-batch")) {
+                allArgs.add(arg);
+              }
+            }
+            for (String arg: lineArgs) {
+              allArgs.add(arg);
+            }
+
+            CompilerOptions compilerOptions = processCommandLineOptions(
+                allArgs.toArray(new String[allArgs.size()]));
             if (compilerOptions.shouldBatch()) {
               System.err.println("-batch ignored: Already in batch mode.");
             }
             return compilerMain(compilerOptions);
           }
         });
       } else {
         result = compilerMain(topCompilerOptions);
       }
     } catch (Throwable t) {
@@ skipping 295 matching lines @@
         return unit;
       }
     }
     return null;
   }
 
   public static LibraryUnit getCoreLib(LibraryUnit libraryUnit) {
     return findLibrary(libraryUnit, "dart:core", new HashSet<LibraryElement>());
   }
 }