fix for bin/devc relative path

lib/src/compiler.dart

 // Copyright (c) 2015, 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.
 
 /// Command line tool to run the checker on a Dart program.
 library dev_compiler.src.compiler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
@@ skipping 30 matching lines @@
 /// messages.
 StreamSubscription setupLogger(Level level, printFn) {
   Logger.root.level = level;
   return Logger.root.onRecord.listen((LogRecord rec) {
     printFn('${rec.level.name.toLowerCase()}: ${rec.message}');
   });
 }
 
 class BatchCompiler extends AbstractCompiler {
   JSGenerator _jsGen;
+  LibraryElement _dartCore;
+  String _runtimeOutputDir;
 
   /// Already compiled sources, so we don't compile them again.
   final _compiled = new HashSet<LibraryElement>();
 
   bool _failure = false;
   bool get failure => _failure;
 
   BatchCompiler(AnalysisContext context, CompilerOptions options,
       {AnalysisErrorListener reporter})
       : super(context, options, reporter) {
+    _inputBaseDir = options.inputBaseDir;
     if (outputDir != null) {
       _jsGen = new JSGenerator(this);
+      _runtimeOutputDir = path.join(outputDir, 'dev_compiler', 'runtime');
     }
+    _dartCore = context.typeProvider.objectType.element.library;
   }
 
   void reset() {
     _compiled.clear();
   }
 
   /// Compiles every file in [options.inputs].
   /// Returns true on successful compile.
   bool run() {
     var clock = new Stopwatch()..start();
     options.inputs.forEach(compileFromUriString);
     clock.stop();
     var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2);
     _log.fine('Compiled ${_compiled.length} libraries in ${time} s\n');
 
     return !_failure;
   }
 
   void compileFromUriString(String uriString) {
-    compileFromUri(stringToUri(uriString));
+    _compileFromUri(stringToUri(uriString));
   }
 
-  void compileFromUri(Uri uri) {
+  void _compileFromUri(Uri uri) {
+    if (!uri.isAbsolute) {
+      throw new ArgumentError.value('$uri', 'uri', 'must be absolute');
+    }
     var source = context.sourceFactory.forUri(Uri.encodeFull('$uri'));
-    if (source == null) throw new ArgumentError.value(
-        uri.toString(), 'uri', 'could not find source for');
+    if (source == null) {
+      throw new ArgumentError.value('$uri', 'uri', 'could not find source for');
+    }
     compileSource(source);
   }
 
   void compileSource(Source source) {
     if (AnalysisEngine.isHtmlFileName(source.uri.path)) {
-      compileHtml(source);
+      _compileHtml(source);
       return;
     }
-
     compileLibrary(context.computeLibraryElement(source));
   }
 
   void compileLibrary(LibraryElement library) {
     if (!_compiled.add(library)) return;
-    if (!options.checkSdk && library.source.uri.scheme == 'dart') return;
+
+    if (!options.checkSdk && library.source.uri.scheme == 'dart') {
+      if (_jsGen != null) _copyDartRuntime();
+      return;
+    }
 
     // TODO(jmesserly): in incremental mode, we can skip the transitive
     // compile of imports/exports.
+    compileLibrary(_dartCore); // implicit dart:core dependency
     library.importedLibraries.forEach(compileLibrary);
     library.exportedLibraries.forEach(compileLibrary);
 
     var unitElements = [library.definingCompilationUnit]..addAll(library.parts);
     var units = <CompilationUnit>[];
 
     bool failureInLib = false;
     for (var element in unitElements) {
       var unit = context.resolveCompilationUnit(element.source, library);
       units.add(unit);
       failureInLib = logErrors(element.source) || failureInLib;
       checker.visitCompilationUnit(unit);
       if (checker.failure) failureInLib = true;
     }
 
     if (failureInLib) {
       _failure = true;
       if (!options.codegenOptions.forceCompile) return;
     }
 
     if (_jsGen != null) {
       var unit = units.first;
       var parts = units.skip(1).toList();
       _jsGen.generateLibrary(new LibraryUnit(unit, parts));
     }
   }
 
-  void compileHtml(Source source) {
+  void _copyDartRuntime() {
+    for (var file in defaultRuntimeFiles) {
+      var input = path.join(options.runtimeDir, file);
+      var output = path.join(_runtimeOutputDir, file);
+      new Directory(path.dirname(output)).createSync(recursive: true);
+      new File(input).copySync(output);
+    }
+  }
+
+  void _compileHtml(Source source) {
     // TODO(jmesserly): reuse DartScriptsTask instead of copy/paste.
     var contents = context.getContents(source);
     var document = html.parse(contents.data, generateSpans: true);
     var scripts = document.querySelectorAll('script[type="application/dart"]');
 
     var loadedLibs = new LinkedHashSet<Uri>();
 
+    var htmlOutDir = path.dirname(getOutputPath(source.uri));
     for (var script in scripts) {
       Source scriptSource = null;
       var srcAttr = script.attributes['src'];
       if (srcAttr == null) {
         if (script.hasContent()) {
           var fragments = <ScriptFragment>[];
           for (var node in script.nodes) {
             if (node is html.Text) {
               var start = node.sourceSpan.start;
               fragments.add(new ScriptFragment(
                   start.offset, start.line, start.column, node.data));
             }
           }
           scriptSource = new DartScript(source, fragments);
         }
       } else if (AnalysisEngine.isDartFileName(srcAttr)) {
         scriptSource = context.sourceFactory.resolveUri(source, srcAttr);
       }
 
       if (scriptSource != null) {
         var lib = context.computeLibraryElement(scriptSource);
         compileLibrary(lib);
-        script.replaceWith(_linkLibraries(lib, loadedLibs));
+        script.replaceWith(_linkLibraries(lib, loadedLibs, from: htmlOutDir));
       }
     }
 
-    // TODO(jmesserly): we need to clean this up so we aren't treating these
-    // as a special case.
-    for (var file in defaultRuntimeFiles) {
-      var input = path.join(options.runtimeDir, file);
-      var output = path.join(outputDir, runtimeFileOutput(file));
-      new Directory(path.dirname(output)).createSync(recursive: true);
-      new File(input).copySync(output);
-    }
-
     new File(getOutputPath(source.uri)).openSync(mode: FileMode.WRITE)
       ..writeStringSync(document.outerHtml)
       ..writeStringSync('\n')
       ..closeSync();
   }
 
   html.DocumentFragment _linkLibraries(
-      LibraryElement mainLib, LinkedHashSet<Uri> loaded) {
+      LibraryElement mainLib, LinkedHashSet<Uri> loaded, {String from}) {
+    assert(from != null);
     var alreadyLoaded = loaded.length;
     _collectLibraries(mainLib, loaded);
 
     var newLibs = loaded.skip(alreadyLoaded);
     var df = new html.DocumentFragment();
-    for (var path in defaultRuntimeFiles) {
-      df.append(html_codegen.libraryInclude(runtimeFileOutput(path)));
+
+    for (var uri in newLibs) {
+      if (uri.scheme == 'dart') {
+        if (uri.path == 'core') {
+          // TODO(jmesserly): it would be nice to not special case these.
+          for (var file in defaultRuntimeFiles) {
+            file = path.join(_runtimeOutputDir, file);
+            df.append(
+                html_codegen.libraryInclude(path.relative(file, from: from)));
+          }
+        }
+      } else {
+        var file = path.join(outputDir, getModulePath(uri));
+        df.append(html_codegen.libraryInclude(path.relative(file, from: from)));
+      }
     }
-    for (var uri in newLibs) {
-      if (uri.scheme == 'dart') continue;
-      df.append(html_codegen.libraryInclude(getModulePath(uri)));
-    }
+
     df.append(html_codegen.invokeMain(getModuleName(mainLib.source.uri)));
     return df;
   }
 
   void _collectLibraries(LibraryElement lib, LinkedHashSet<Uri> loaded) {
     var uri = lib.source.uri;
     if (!loaded.add(uri)) return;
+    _collectLibraries(_dartCore, loaded);
     for (var l in lib.importedLibraries) _collectLibraries(l, loaded);
     for (var l in lib.exportedLibraries) _collectLibraries(l, loaded);
     // Move the item to the end of the list.
     loaded.remove(uri);
     loaded.add(uri);
   }
-
-  String runtimeFileOutput(String file) =>
-      path.join('dev_compiler', 'runtime', file);
 }
 
 abstract class AbstractCompiler {
   final CompilerOptions options;
   final AnalysisContext context;
   final CodeChecker checker;
 
   AbstractCompiler(AnalysisContext context, CompilerOptions options,
       [AnalysisErrorListener reporter])
       : context = context,
         options = options,
         checker = createChecker(context.typeProvider, options.strongOptions,
             reporter == null ? AnalysisErrorListener.NULL_LISTENER : reporter) {
     enableDevCompilerInference(context, options.strongOptions);
   }
 
   static CodeChecker createChecker(TypeProvider typeProvider,
       StrongModeOptions options, AnalysisErrorListener reporter) {
     return new CodeChecker(
         new RestrictedRules(typeProvider, options: options), reporter, options);
   }
 
   String get outputDir => options.codegenOptions.outputDir;
   TypeRules get rules => checker.rules;
   AnalysisErrorListener get reporter => checker.reporter;
 
   Uri stringToUri(String uriString) {
     var uri = uriString.startsWith('dart:') || uriString.startsWith('package:')
         ? Uri.parse(uriString)
-        : new Uri.file(uriString);
+        : new Uri.file(path.absolute(uriString));
     return uri;
   }
 
   /// Directory presumed to be the common prefix for all input file:// URIs.
   /// Used when computing output paths.
   ///
   /// For example:
   ///   dartdevc -o out foo/a.dart bar/b.dart
   ///
   /// Will produce:
@@ skipping 43 matching lines @@
   /// * dart:core -> dart/core
   /// * file:foo/bar/baz.dart -> foo/bar/baz
   /// * package:qux/qux.dart -> qux/qux
   ///
   /// For file: URLs this will also make them relative to [inputBaseDir].
   // TODO(jmesserly): we need to figure out a way to keep package and file URLs
   // from conflicting.
   String getModuleName(Uri uri) {
     var filepath = path.withoutExtension(uri.path);
     if (uri.scheme == 'dart') {
-      filepath = 'dart/$filepath';
+      return 'dart/$filepath';
     } else if (uri.scheme == 'file') {
-      filepath = path.relative(filepath, from: inputBaseDir);
+      return path.relative(filepath, from: inputBaseDir);
     } else {
       assert(uri.scheme == 'package');
       // filepath is good here, we want the output to start with a directory
       // matching the package name.
+      return filepath;
     }
-    return filepath;
   }
 
   /// Log any errors encountered when resolving [source] and return whether any
   /// errors were found.
   bool logErrors(Source source) {
     List<AnalysisError> errors = context.computeErrors(source);
     bool failure = false;
     if (errors.isNotEmpty) {
       for (var error in errors) {
         // Always skip TODOs.
@@ skipping 33 matching lines @@
   'dart.async',
   'dart._foreign_helper',
   'dart._js_embedded_names',
   'dart._js_helper',
   'dart.isolate',
   'dart.typed_data',
   'dart._native_typed_data',
   'dart._isolate_helper',
   'dart._js_primitives',
   'dart.convert',
+  // TODO(jmesserly): these are not part of corelib library cycle, and shouldn't
+  // be listed here. Instead, their source should be copied on demand if they
+  // are actually used by the application.
   'dart.mirrors',
   'dart._js_mirrors',
   'dart.js'
   // _foreign_helper is not included, as it only defines the JS builtin that
   // the compiler handles at compile time.
 ];
 
 /// Runtime files added to all applications when running the compiler in the
 /// command line.
 final defaultRuntimeFiles = () {
   var files = [
     'harmony_feature_check.js',
     'dart_utils.js',
     'dart_library.js',
     '_errors.js',
     '_types.js',
     '_rtti.js',
     '_classes.js',
     '_operations.js',
     'dart_runtime.js',
   ];
   files.addAll(corelibOrder.map((l) => l.replaceAll('.', '/') + '.js'));
   return files;
 }();
 
 final _log = new Logger('dev_compiler.src.compiler');