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);
+
+      // TODO(jmesserly): this hack is to avoid compiling the same compilation
+      // unit to JS twice. We mutate the AST, so it's not safe to run more than
+      // once on the same unit.
+      if (element.library == library) {
+        if (unit.getProperty(_propertyName) == true) return;
+        unit.setProperty(_propertyName, true);
+      }
+
       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();
 
-      // TODO(jmesserly): this hack is to avoid compiling the same compilation
-      // unit to JS twice. We mutate the AST, so it's not safe to run more than
-      // once on the same unit.
-      if (unit.getProperty(_propertyName) == true) return;
-      unit.setProperty(_propertyName, true);
-
       _jsGen.generateLibrary(new LibraryUnit(unit, parts));
     }
   }
 
   static const String _propertyName = 'dev_compiler.BatchCompiler.isCompiled';

[vsm, 2015/07/23 16:42:45]

Perhaps rename _propertyName to _isCompiled?

[Jennifer Messerly, 2015/07/23 16:50:35]

_propertyName is gone after I rebase against master.

 
-  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) {

[vsm, 2015/07/23 16:42:45]

Will this pick up dart:mirrors?  I think core doesn't actually depend on that.

[Jennifer Messerly, 2015/07/23 16:50:35]

dart:mirrors depends on dart:core, so we always hit core eventually, at which
point we make the whole SDK available (everything hard coded in
defaultRuntimeFiles), which includes mirrors.

It's a good observation, though: we treat the whole SDK as a unit, which is no
longer true, since dart:mirrors and dart:js aren't part of the ginormous library
cycle that is core.

that's what my TODO was trying to explain, though not sure it captured the issue
well. I'll add another comment down by defaultRuntimeFiles.

We shouldn't really need these special cases at all: instead, including an SDK
lib should cause it to be "compiled" (which should be an instant cache hit,
assuming incremental works). But right now, that's not how things work.

+            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 59 matching lines @@
     '_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');