Fixes #179 -- compile error if editing files during server mode

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:path/path.dart' as path;
 
 import 'package:dev_compiler/src/codegen/ast_builder.dart' show AstBuilder;
 import 'package:dev_compiler/src/codegen/reify_coercions.dart'
     show CoercionReifier;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
+import 'package:dev_compiler/devc.dart' show CompilerContext;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
 
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // dart_runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
+  final CompilerContext compiler;
   final CompilerOptions options;
   final TypeRules rules;
   final LibraryInfo libraryInfo;
 
   /// The global extension method table.
   final HashMap<String, List<InterfaceType>> _extensionMethods;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
   final HashSet<FieldElement> _fieldsNeedingStorage;
@@ skipping 18 matching lines @@
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _exportsVar = new JS.TemporaryId('exports');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
-  JSCodegenVisitor(this.options, this.rules, this.libraryInfo,
-      this._extensionMethods, this._fieldsNeedingStorage) {
+  JSCodegenVisitor(CompilerContext compiler, this.libraryInfo,
+      this._extensionMethods, this._fieldsNeedingStorage)
+      : compiler = compiler,
+        options = compiler.options,
+        rules = compiler.rules {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
   }
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
-    new CoercionReifier(library, rules, options).reify();
+    new CoercionReifier(library, compiler).reify();
 
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var libraryDir = unit.directives.first;
       if (libraryDir is LibraryDirective) {
         var jsName = getAnnotationValue(libraryDir, _isJsNameAnnotation);
         jsDefaultValue = getConstantField(jsName, 'name', types.stringType);
       }
     }
     if (jsDefaultValue == null) jsDefaultValue = '{}';
@@ skipping 2277 matching lines @@
   JS.Identifier _libraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 }
 
 class JSGenerator extends CodeGenerator {
-  final CompilerOptions options;
-
   /// For fast lookup of extension methods, we first check the name, then do a
   /// (possibly expensive) subtype test to see if it matches one of the types
   /// that declares that method.
   final _extensionMethods = new HashMap<String, List<InterfaceType>>();
 
-  JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
-      : super(outDir, root, rules) {
+  JSGenerator(CompilerContext context) : super(context) {
 
     // TODO(jacobr): determine the the set of types with extension methods from
     // the annotations rather than hard coding the list once the analyzer
     // supports summaries.
     var extensionTypes = [types.listType, types.iterableType];
     for (var type in extensionTypes) {
       type = fillDynamicTypeArgs(type, rules.provider);
       var e = type.element;
       var names = new HashSet<String>()
         ..addAll(e.methods.map((m) => m.name))
         ..addAll(e.accessors.map((m) => m.name));
       for (var name in names) {
         _extensionMethods.putIfAbsent(name, () => []).add(type);
       }
     }
   }
 
   TypeProvider get types => rules.provider;
 
   String generateLibrary(LibraryUnit unit, LibraryInfo info) {
     var fields = findFieldsNeedingStorage(unit);
     var codegen =
-        new JSCodegenVisitor(options, rules, info, _extensionMethods, fields);
+        new JSCodegenVisitor(compiler, info, _extensionMethods, fields);
     var module = codegen.emitLibrary(unit);
     var dir = path.join(outDir, jsOutputPath(info, root));
     return writeJsLibrary(module, dir, emitSourceMaps: options.emitSourceMaps);
   }
 }
 
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
@@ skipping 35 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }