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 40 matching lines @@
 
   /// 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);
     }
   }
 
   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));
   }
 
   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);
       return;
     }
 
     compileLibrary(context.computeLibraryElement(source));
   }
 
   void compileLibrary(LibraryElement library) {
     if (!_compiled.add(library)) return;
     if (!options.checkSdk && library.source.uri.scheme == 'dart') return;
 
     // TODO(jmesserly): in incremental mode, we can skip the transitive
     // compile of imports/exports.
     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';
 
   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));
+      var output = path.join(htmlOutDir, 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 file in defaultRuntimeFiles) {
+      df.append(html_codegen.libraryInclude(runtimeFileOutput(file)));

[vsm, 2015/07/20 16:11:16]

I think you need to make a relative path wrt *from* here as well.

[Jennifer Messerly, 2015/07/20 16:32:31]

It's already a relative path. The (poorly named) runtimeFileOutput just prepends
"dev_compiler/runtime". So the path ends up as
"dev_compiler/runtime/dart/core.js" for example. Which results in the HTML
saying `<script src="dev_compiler/runtime/dart/core.js">` which is exactly what
we want. Then above, all of the runtime files are copied into the "htmlOutDir"
(line 191), so you get a structure like:

sunflower/
- sunflower.html
- dev_compiler/
- - runtime/
- - - dart/
- - - - core.js

The scripts match up with the HTML file's relative path.

This does mean multiple every HTML file gets a copy of the runtime next to it.
This roughly matches what we used to do (and still do in server mode), for
better or worse. I basically kept it because it matches what server does. Though
I agree, it's not right longer term.

For demo purposes, could you have all of your HTML files in the same directory?
Alternatively, would "../" be okay in the HTML file, if the input base directory
was above the HTML? In that case, I'd probably have it output the runtime files
not as part of compileHtml, but as part of `run`. The invariant would be one
batch compile == one runtime. If you want me to take that route, I'd prefer
doing it in a follow up, as it might cause collateral test damage :)

Anyway, I'm happy to continue tweaking all of this stuff. It's just hard to
think about the right thing when we still have our server. I feel like it has
taken a lot of energy to try and maintain the system, when we know ultimately
it's not the right direction w.r.t. analyzer integration. Not sure the smartest
approach at this point. I'm starting to think if we had a very simple file
watcher (perhaps borrowing some code from analysis_server), that could get us to
a saner system in the meantime.

     }
     for (var uri in newLibs) {
       if (uri.scheme == 'dart') continue;
-      df.append(html_codegen.libraryInclude(getModulePath(uri)));
+      var jsPath = getModulePath(uri);
+      jsPath = path.relative(path.join(outputDir, jsPath), from: from);
+      df.append(html_codegen.libraryInclude(jsPath));
     }
     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;
     for (var l in lib.importedLibraries) _collectLibraries(l, loaded);
     for (var l in lib.exportedLibraries) _collectLibraries(l, loaded);
@@ skipping 26 matching lines @@
         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');