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

lib/src/codegen/reify_coercions.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.reify_coercions;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:logging/logging.dart' as logger;
-import 'package:source_span/source_span.dart' show SourceFile;
 
+import 'package:dev_compiler/devc.dart' show AbstractCompiler;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart' show CompilerOptions;
 import 'package:dev_compiler/src/utils.dart' as utils;
 
 import 'ast_builder.dart';
 
 final _log = new logger.Logger('dev_compiler.reify_coercions');
 
 // TODO(leafp) Factor this out or use an existing library
@@ skipping 78 matching lines @@
   void annotateFunctionExpression(FunctionExpression e, DartType returnType) {
     // Implicitly changes e.staticType
     (e.element as ExecutableElementImpl).returnType = returnType;
   }
 }
 
 // This class implements a pass which modifies (in place) the ast replacing
 // abstract coercion nodes with their dart implementations.
 class CoercionReifier extends analyzer.GeneralizingAstVisitor<Object>
     with ConversionVisitor<Object> {
+  final AnalysisContext _context;
   final CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   final LibraryUnit _library;
-  SourceFile _file;
   bool _skipCoercions = false;
   final TypeRules _rules;
   final _Inference _inferrer;
   final InstrumentedRuntime _runtime;
   final CompilerOptions _options;
 
+  CompilationUnit _unit;
+
   CoercionReifier._(this._cm, this._tm, this._vm, this._library, this._rules,
-      this._inferrer, this._runtime, this._options);
+      this._inferrer, this._runtime, this._context, this._options);
 
-  factory CoercionReifier(
-      LibraryUnit library, TypeRules rules, CompilerOptions options,
+  factory CoercionReifier(LibraryUnit library, AbstractCompiler compiler,
       [InstrumentedRuntime runtime]) {
     var vm = new VariableManager();
     var tm =
         new TypeManager(library.library.element.enclosingElement, vm, runtime);
+    var rules = compiler.rules;
     var cm = new CoercionManager(vm, tm, rules, runtime);
     var inferrer = new _Inference(rules, tm);
+    var context = compiler.context;
+    var options = compiler.options;
     return new CoercionReifier._(
-        cm, tm, vm, library, rules, inferrer, runtime, options);
+        cm, tm, vm, library, rules, inferrer, runtime, context, options);
   }
 
   // This should be the entry point for this class.  Entering via the
   // visit functions directly may not do the right thing with respect
   // to discharging the collected definitions.
   // Returns the set of new type identifiers added by the reifier
   Map<Identifier, NewTypeIdDesc> reify() {
     _library.partsThenLibrary.forEach(generateUnit);
     return _tm.addedTypes;
   }
 
   void generateUnit(CompilationUnit unit) {
-    _file = new SourceFile(unit.element.source.contents.data,
-        url: unit.element.source.uri);
+    _unit = unit;
     visitCompilationUnit(unit);
-    _file = null;
+    _unit = null;
   }
 
   ///////////////// Private //////////////////////////////////
 
   String _locationInfo(Expression e) {
-    if (_file != null) {
+    if (_unit != null) {
       final begin = e is AnnotatedNode
           ? (e as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
           : e.offset;
       if (begin != 0 && e.end > begin) {
-        var span = _file.span(begin, e.end);
+        var span = utils.createSpan(_context, _unit, begin, e.end);
         var s = span.message("Cast");
         return s.substring(0, s.indexOf("Cast"));
       }
     }
     return null;
   }
 
   static String _conversionKind(Conversion node) {
     if (node is ClosureWrapLiteral) return "WrapLiteral";
     if (node is ClosureWrap) return "Wrap";
@@ skipping 685 matching lines @@
     assert(_runtime != null);
     if (t.typeArguments != null && t.typeArguments.length > 0) {
       var w = AstBuilder.identifierFromString("_");
       var fp = AstBuilder.simpleFormal(w, t);
       var f = AstBuilder.blockFunction(<FormalParameter>[fp], <Statement>[]);
       return _runtime.type(f);
     }
     return t.name;
   }
 }