Refactor CompilerOutput

tests/compiler/dart2js/mock_compiler.dart

 // Copyright (c) 2016, 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 mock_compiler;
 
 import 'dart:async';
 import 'dart:collection';
 
-import 'package:compiler/compiler.dart' as api;
+import 'package:compiler/compiler_new.dart' as api;
 import 'package:compiler/src/common/names.dart' show Uris;
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/elements/resolution_types.dart'
     show ResolutionDartType;
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/diagnostics/source_span.dart';
 import 'package:compiler/src/diagnostics/spannable.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/visitor.dart';
 import 'package:compiler/src/js_backend/backend_helpers.dart'
     show BackendHelpers;
 import 'package:compiler/src/js_backend/lookup_map_analysis.dart'
     show LookupMapAnalysis;
 import 'package:compiler/src/io/source_file.dart';
 import 'package:compiler/src/options.dart' show CompilerOptions;
 import 'package:compiler/src/resolution/members.dart';
 import 'package:compiler/src/resolution/registry.dart';
 import 'package:compiler/src/resolution/scope.dart';
 import 'package:compiler/src/resolution/tree_elements.dart';
 import 'package:compiler/src/resolved_uri_translator.dart';
 import 'package:compiler/src/script.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/old_to_new_api.dart';
 import 'parser_helper.dart';
 
 import 'package:compiler/src/elements/modelx.dart'
-    show ElementX, LibraryElementX, ErroneousElementX, FunctionElementX;
+    show ErroneousElementX, FunctionElementX;
 
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/common/tasks.dart' show Measurer;
 
 import 'package:compiler/src/deferred_load.dart'
     show DeferredLoadTask, OutputUnit;
 
 import 'mock_libraries.dart';
 import 'diagnostic_helper.dart';
 
 export 'diagnostic_helper.dart';
 
 final Uri PATCH_CORE = new Uri(scheme: 'patch', path: 'core');
 
 typedef String LibrarySourceProvider(Uri uri);
 
 class MockCompiler extends Compiler {
-  api.DiagnosticHandler diagnosticHandler;
+  api.CompilerDiagnostics diagnosticHandler;
 
   /// Expected number of warnings. If `null`, the number of warnings is
   /// not checked.
   final int expectedWarnings;
 
   /// Expected number of errors. If `null`, the number of errors is not checked.
   final int expectedErrors;
   final Map<String, SourceFile> sourceFiles;
   Node parsedTree;
   final String testedPatchVersion;
@@ skipping 13 matching lines @@
       bool analyzeOnly: false,
       bool preserveComments: false,
       // Our unit tests check code generation output that is
       // affected by inlining support.
       bool disableInlining: true,
       bool trustTypeAnnotations: false,
       bool trustJSInteropTypeAnnotations: false,
       bool enableAsyncAwait: false,
       int this.expectedWarnings,
       int this.expectedErrors,
-      api.CompilerOutputProvider outputProvider,
+      api.CompilerOutput outputProvider,
       String patchVersion,
       LibrarySourceProvider this.librariesOverride})
       : sourceFiles = new Map<String, SourceFile>(),
         testedPatchVersion = patchVersion,
         super(
             options: new CompilerOptions(
                 entryPoint: new Uri(scheme: 'mock'),
                 libraryRoot: Uri.parse('placeholder_library_root_for_mock/'),
                 enableTypeAssertions: enableTypeAssertions,
                 enableUserAssertions: enableUserAssertions,
                 disableInlining: disableInlining,
                 enableAssertMessage: true,
                 enableMinification: enableMinification,
                 disableTypeInference: disableTypeInference,
                 analyzeAll: analyzeAll,
                 analyzeOnly: analyzeOnly,
                 preserveComments: preserveComments,
                 trustTypeAnnotations: trustTypeAnnotations,
                 trustJSInteropTypeAnnotations: trustJSInteropTypeAnnotations,
                 shownPackageWarnings: const []),
-            outputProvider: new LegacyCompilerOutput(outputProvider)) {
+            outputProvider: outputProvider) {
     deferredLoadTask = new MockDeferredLoadTask(this);
 
     registerSource(
         Uris.dart_core, buildLibrarySource(DEFAULT_CORE_LIBRARY, coreSource));
     registerSource(PATCH_CORE, DEFAULT_PATCH_CORE_SOURCE);
 
     registerSource(BackendHelpers.DART_JS_HELPER,
         buildLibrarySource(DEFAULT_JS_HELPER_LIBRARY));
     registerSource(BackendHelpers.DART_FOREIGN_HELPER,
         buildLibrarySource(DEFAULT_FOREIGN_HELPER_LIBRARY));
@@ skipping 74 matching lines @@
       int begin;
       int end;
       String text = '${message.message}';
       if (span != null) {
         uri = span.uri;
         begin = span.begin;
         end = span.end;
       }
       diagnosticCollector.report(message.message, uri, begin, end, text, kind);
       if (diagnosticHandler != null) {
-        diagnosticHandler(uri, begin, end, text, kind);
+        diagnosticHandler.report(message.message, uri, begin, end, text, kind);
       }
     }
 
     processMessage(message, kind);
     infoMessages.forEach((i) => processMessage(i, api.Diagnostic.INFO));
   }
 
   CollectingTreeElements resolveStatement(String text) {
     parsedTree = parseStatement(text);
     return resolveNodeStatement(parsedTree, new MockElement(mainApp));
@@ skipping 114 matching lines @@
 
 // The mock compiler does not split the program in output units.
 class MockDeferredLoadTask extends DeferredLoadTask {
   MockDeferredLoadTask(Compiler compiler) : super(compiler);
 
   OutputUnit getElementOutputUnit(dynamic dependency) {
     return mainOutputUnit;
   }
 }
 
-api.DiagnosticHandler createHandler(MockCompiler compiler, String text,
+api.CompilerDiagnostics createHandler(MockCompiler compiler, String text,
     {bool verbose: false}) {
-  return (uri, int begin, int end, String message, kind) {
+  return new LegacyCompilerDiagnostics(
+      (uri, int begin, int end, String message, kind) {
     if (kind == api.Diagnostic.VERBOSE_INFO && !verbose) return;
     SourceFile sourceFile;
     if (uri == null) {
       sourceFile = new StringSourceFile.fromName('analysis', text);
     } else {
       sourceFile = compiler.sourceFiles[uri.toString()];
     }
     if (sourceFile != null && begin != null && end != null) {
       print('${kind}: ${sourceFile.getLocationMessage(message, begin, end)}');
     } else {
       print('${kind}: $message');
     }
-  };
+  });
 }
 
 class MockElement extends FunctionElementX {
   MockElement(Element enclosingElement)
       : super('', ElementKind.FUNCTION, Modifiers.EMPTY, enclosingElement);
 
   get node => null;
 
   parseNode(_) => null;
 
   bool get hasNode => false;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 }
 
 // TODO(herhut): Disallow warnings and errors during compilation by default.
 MockCompiler compilerFor(String code, Uri uri,
     {bool analyzeAll: false,
     bool analyzeOnly: false,
     Map<String, String> coreSource,
     bool disableInlining: true,
     bool minify: false,
     bool trustTypeAnnotations: false,
     bool enableTypeAssertions: false,
     bool enableUserAssertions: false,
     int expectedErrors,
     int expectedWarnings,
-    api.CompilerOutputProvider outputProvider}) {
+    api.CompilerOutput outputProvider}) {
   MockCompiler compiler = new MockCompiler.internal(
       analyzeAll: analyzeAll,
       analyzeOnly: analyzeOnly,
       coreSource: coreSource,
       disableInlining: disableInlining,
       enableMinification: minify,
       trustTypeAnnotations: trustTypeAnnotations,
       enableTypeAssertions: enableTypeAssertions,
       enableUserAssertions: enableUserAssertions,
       expectedErrors: expectedErrors,
       expectedWarnings: expectedWarnings,
       outputProvider: outputProvider);
   compiler.registerSource(uri, code);
   compiler.diagnosticHandler = createHandler(compiler, code);
   return compiler;
 }