Handle symbol literals in closed_world2_test

tests/compiler/dart2js/analyze_only_test.dart

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file

[Siggi Cherem (dart-lang), 2017/05/02 19:38:19]

was this test unnecessary? Not sure why it got deleted with the rest of the
change.

[Johnni Winther, 2017/05/03 08:37:10]

It was accidentally emptied. Re-inserted

-// 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.
 
-// Smoke test of the dart2js compiler API.
-library analyze_only;
-
-import "package:expect/expect.dart";
-import 'dart:async';
-import "package:async_helper/async_helper.dart";
-
-import '../../utils/dummy_compiler_test.dart' as dummy;
-import 'package:compiler/compiler_new.dart';
-import 'package:compiler/src/options.dart';
-import 'package:compiler/src/commandline_options.dart';
-import 'package:compiler/src/diagnostics/messages.dart'
-    show MessageKind, MessageTemplate;
-import 'package:compiler/src/old_to_new_api.dart';
-
-import 'output_collector.dart';
-
-runCompiler(String main, List<String> options,
-    onValue(String code, List errors, List warnings)) {
-  List errors = new List();
-  List warnings = new List();
-
-  Future<String> localProvider(Uri uri) {
-    if (uri.scheme != 'main') return dummy.provider(uri);
-    return new Future<String>.value(main);
-  }
-
-  void localHandler(
-      Uri uri, int begin, int end, String message, Diagnostic kind) {
-    dummy.handler(uri, begin, end, message, kind);
-    if (kind == Diagnostic.ERROR) {
-      errors.add(message);
-    } else if (kind == Diagnostic.WARNING) {
-      warnings.add(message);
-    }
-  }
-
-  print('-----------------------------------------------');
-  print('main source:\n$main');
-  print('options: $options\n');
-  asyncStart();
-  OutputCollector outputCollector = new OutputCollector();
-  Future<CompilationResult> result = compile(
-      new CompilerOptions.parse(
-          entryPoint: new Uri(scheme: 'main'),
-          libraryRoot: new Uri(scheme: 'lib', path: '/'),
-          packageRoot: new Uri(scheme: 'package', path: '/'),
-          options: options),
-      new LegacyCompilerInput(localProvider),
-      new LegacyCompilerDiagnostics(localHandler),
-      outputCollector);
-  result
-      .then((_) {
-        onValue(outputCollector.getOutput('', OutputType.js), errors, warnings);
-      }, onError: (e, st) {
-        throw 'Compilation failed: ${e} ${st}';
-      })
-      .then(asyncSuccess)
-      .catchError((error, stack) {
-        print('\n\n-----------------------------------------------');
-        print('main source:\n$main');
-        print('options: $options\n');
-        print('threw:\n $error\n$stack');
-        print('-----------------------------------------------\n\n');
-        throw error;
-      });
-}
-
-main() {
-  runCompiler("", [Flags.generateCodeWithCompileTimeErrors],
-      (String code, List errors, List warnings) {
-    Expect.isNotNull(code);
-    Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
-    MessageTemplate template =
-        MessageTemplate.TEMPLATES[MessageKind.MISSING_MAIN];
-    Expect.equals("${template.message({'main': 'main'})}", warnings.single);
-  });
-
-  runCompiler("main() {}", [Flags.generateCodeWithCompileTimeErrors],
-      (String code, List errors, List warnings) {
-    Expect.isNotNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-
-  runCompiler("", [Flags.analyzeOnly],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
-    MessageTemplate template =
-        MessageTemplate.TEMPLATES[MessageKind.CONSIDER_ANALYZE_ALL];
-    Expect.equals("${template.message({'main': 'main'})}", warnings.single);
-  });
-
-  runCompiler("main() {}", [Flags.analyzeOnly],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-
-  runCompiler("Foo foo; // Unresolved but not analyzed.", [Flags.analyzeOnly],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
-    MessageTemplate template =
-        MessageTemplate.TEMPLATES[MessageKind.CONSIDER_ANALYZE_ALL];
-    Expect.equals("${template.message({'main': 'main'})}", warnings.single);
-  });
-
-  runCompiler(
-      """main() {
-         Foo foo; // Unresolved and analyzed.
-       }""",
-      [Flags.analyzeOnly], (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.equals(1, warnings.length);
-    Expect.equals("Cannot resolve type 'Foo'.", warnings[0].toString());
-  });
-
-  runCompiler(
-      """main() {
-         Foo foo; // Unresolved and analyzed.
-       }""",
-      [Flags.analyzeOnly, Flags.analyzeSignaturesOnly],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-
-  runCompiler("Foo foo; // Unresolved and analyzed.", [
-    Flags.analyzeOnly,
-    Flags.analyzeAll
-  ], (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.equals("Cannot resolve type 'Foo'.", warnings[0].toString());
-  });
-
-  runCompiler(
-      """Foo foo; // Unresolved and analyzed.
-       main() {}""",
-      [Flags.analyzeOnly, Flags.analyzeAll],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty, 'Unexpected errors: $errors.');
-    Expect.equals(1, warnings.length, 'Unexpected warning count: $warnings.');
-    Expect.equals("Cannot resolve type 'Foo'.", warnings[0].toString());
-  });
-
-  runCompiler("", [Flags.analyzeOnly, Flags.analyzeAll],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-
-  // --analyze-signatures-only implies --analyze-only
-  runCompiler("", [Flags.analyzeSignaturesOnly, Flags.analyzeAll],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-
-  // Test that --allow-native-extensions works.
-  runCompiler(
-      """main() {}
-      foo() native 'foo';""",
-      [Flags.analyzeOnly, Flags.allowNativeExtensions],
-      (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(errors.isEmpty);
-    Expect.isTrue(warnings.isEmpty);
-  });
-  runCompiler(
-      """main() {}
-      foo() native 'foo';""",
-      [Flags.analyzeOnly], (String code, List errors, List warnings) {
-    Expect.isNull(code);
-    Expect.isTrue(
-        errors.single.startsWith("'native' modifier is not supported."));
-    Expect.isTrue(warnings.isEmpty);
-  });
-}