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

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/error.dart' as analyzer;
 import 'package:analyzer/src/generated/java_io.dart' show JavaFile;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart'
     show DirectedGraph;
 import 'package:logging/logging.dart' as logger;
 
 import 'package:dev_compiler/src/options.dart';
-import 'package:dev_compiler/src/report.dart';
 import 'package:dev_compiler/src/utils.dart';
 import 'dart_sdk.dart';
 import 'multi_package_resolver.dart';
 
 final _log = new logger.Logger('dev_compiler.src.resolver');
 
+// TODO(jmesserly): this class can be removed, and converted to some top-level
+// methods that create the AnalysisContext.
 /// Encapsulates a resolver from the analyzer package.
 class TypeResolver {

[Jennifer Messerly, 2015/05/13 23:21:16]

happy to remove this type in follow up CL. It doesn't do anything anymore, and
the name is nonsensical. Even the file that it lives in doesn't make sense.

[vsm, 2015/05/14 22:02:08]

sgtm

   final InternalAnalysisContext context;
 
-  final Map<Uri, Source> _sources = <Uri, Source>{};
-
   TypeResolver(DartUriResolver sdkResolver, ResolverOptions options,
       {List otherResolvers})
       : context = _initContext(options) {
     var resolvers = [sdkResolver];
     if (otherResolvers == null) {
       resolvers.add(new FileUriResolver());
       resolvers.add(options.useMultiPackage
           ? new MultiPackageResolver(options.packagePaths)
           : new PackageUriResolver([new JavaFile(options.packageRoot)]));
     } else {
       resolvers.addAll(otherResolvers);
     }
     context.sourceFactory = new SourceFactory(resolvers);
   }
 
   /// Creates a [TypeResolver] that uses a mock 'dart:' library contents.
   TypeResolver.fromMock(
       Map<String, String> mockSources, ResolverOptions options,
       {List otherResolvers})
       : this(
           new MockDartSdk(mockSources, reportMissing: true).resolver, options,
           otherResolvers: otherResolvers);
 
   /// Creates a [TypeResolver] that uses the SDK at the given [sdkPath].
   TypeResolver.fromDir(String sdkPath, ResolverOptions options,
       {List otherResolvers})
       : this(
           new DartUriResolver(new DirectoryBasedDartSdk(new JavaFile(sdkPath))),
           options, otherResolvers: otherResolvers);
-
-  /// Find the corresponding [Source] for [uri].
-  Source findSource(Uri uri) {
-    var source = _sources[uri];
-    if (source != null) return source;
-    return _sources[uri] = context.sourceFactory.forUri('$uri');
-  }
-
-  /// Log any errors encountered when resolving [source] and return whether any
-  /// errors were found.
-  bool logErrors(Source source, CheckerReporter reporter) {
-    List<analyzer.AnalysisError> errors = context.getErrors(source).errors;
-    bool failure = false;
-    if (errors.isNotEmpty) {
-      for (var error in errors) {
-        var message = new AnalyzerError.from(error);
-        if (message.level == logger.Level.SEVERE) failure = true;
-        reporter.log(message);
-      }
-    }
-    return failure;
-  }
-}
-
-class AnalyzerError extends Message {
-  factory AnalyzerError.from(analyzer.AnalysisError error) {
-    var severity = error.errorCode.type.severity;
-    var isError = severity == analyzer.ErrorSeverity.ERROR;
-    var level = isError ? logger.Level.SEVERE : logger.Level.WARNING;
-    int begin = error.offset;
-    int end = begin + error.length;
-    return new AnalyzerError(error.message, level, begin, end);
-  }
-
-  const AnalyzerError(String message, logger.Level level, int begin, int end)
-      : super('[from analyzer]: $message', level, begin, end);
 }
 
 /// Creates an analysis context that contains our restricted typing rules.
 InternalAnalysisContext _initContext(ResolverOptions options) {
   var analysisOptions = new AnalysisOptionsImpl()..cacheSize = 512;
   AnalysisContextImpl res = AnalysisEngine.instance.createAnalysisContext();
   res.analysisOptions = analysisOptions;
   res.libraryResolverFactory =
       (context) => new LibraryResolverWithInference(context, options);
   return res;
@@ skipping 655 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }