Refactor and simplify the dart2dart renamer.

tests/compiler/dart2js/backend_dart/dart_backend_test.dart

 // Copyright (c) 2012, 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.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import '../mock_compiler.dart';
 import '../mock_libraries.dart';
 import 'package:compiler/compiler.dart';
@@ skipping 14 matching lines @@
 Window __window;
 Window get window => __window;
 abstract class Window {
   Navigator get navigator;
 }
 abstract class Navigator {
   String get userAgent;
 }
 ''';
 
-testDart2Dart(String src, {void continuation(String s), bool minify: false,
-    bool stripTypes: false}) {
-  // If continuation is not provided, check that source string remains the same.
-  if (continuation == null) {
-    continuation = (s) { Expect.equals(src, s); };
-  }
-  testDart2DartWithLibrary(src, '', continuation: continuation, minify: minify,
-      stripTypes: stripTypes);
-}
-
 /**
  * Library name is assumed to be 'mylib' in 'mylib.dart' file.
  */
-testDart2DartWithLibrary(
-    String srcMain, String srcLibrary,
-    {void continuation(String s), bool minify: false,
-    bool stripTypes: false}) {
+testDart2Dart(String mainSrc, {String librarySrc,
+                               String expectedResult,
+                               bool minify: false,
+                               bool stripTypes: false}) {
+
+  // If expectedResult is not provided, check that source string remains the
+  // same.
+  if (expectedResult == null) {
+    Expect.equals(null, librarySrc);
+    expectedResult = mainSrc;
+  }
+
   fileUri(path) => new Uri(scheme: 'file', path: path);
 
   final scriptUri = fileUri('script.dart');
   final libUri = fileUri('mylib.dart');
 
   provider(uri) {
-    if (uri == scriptUri) return new Future.value(srcMain);
+    if (uri == scriptUri) return new Future.value(mainSrc);
     if (uri.toString() == libUri.toString()) {
-      return new Future.value(srcLibrary);
+      return new Future.value(librarySrc);
     }
     if (uri.path.endsWith('/core.dart')) {
       return new Future.value(buildLibrarySource(DEFAULT_CORE_LIBRARY));
     } else if (uri.path.endsWith('/core_patch.dart')) {
       return new Future.value(DEFAULT_PATCH_CORE_SOURCE);
     } else if (uri.path.endsWith('/io.dart')) {
       return new Future.value(ioLib);
     } else if (uri.path.endsWith('/js_helper.dart')) {
       return new Future.value(buildLibrarySource(DEFAULT_JS_HELPER_LIBRARY));
     } else if (uri.path.endsWith('/html_dart2js.dart')) {
@@ skipping 14 matching lines @@
       Expect.fail('$uri: $begin-$end: $message [$kind]');
     }
   }
 
   final options = <String>['--output-type=dart'];
   // Some tests below are using dart:io.
   options.add('--categories=Client,Server');
   if (minify) options.add('--minify');
   if (stripTypes) options.add('--force-strip=types');
 
-  asyncTest(() => compile(
-      scriptUri,
-      fileUri('libraryRoot/'),
-      fileUri('packageRoot/'),
-      provider,
-      handler,
-      options).then(continuation));
+  asyncTest(() {
+    return compile(
+        scriptUri,
+        fileUri('libraryRoot/'),
+        fileUri('packageRoot/'),
+        provider,
+        handler,
+        options).then((s) {
+      Expect.equals(expectedResult, s);
+    });
+  });
 }
 
 testSimpleFileUnparse() {
   final src = '''
 should_be_dropped() {
 }
 
 should_be_kept() {
 }
 
 main() {
   should_be_kept();
 }
 ''';
-  testDart2Dart(src, continuation: (String s) {
-    print(s);
-    Expect.equals('''
+  testDart2Dart(src, expectedResult: '''
 should_be_kept() {}
 main() {
   should_be_kept();
 }
-''', s);
-  });
+''');
 }
 testTopLevelField() {
   testDart2Dart('''
 final String x = "asd";
 main() {
   x;
 }
 ''');
 }
 
@@ skipping 188 matching lines @@
   mylib.globalVarInitialized2;
   mylib.globalfoo();
   mylib.A.field;
   mylib.A.staticfoo();
   new mylib.A();
   new mylib.A.fromFoo();
   new mylib.A().foo();
 }
 ''';
   var expectedResult = '''
+globalfoo_A() {}
+var globalVar_A;
+var globalVarInitialized_A = 6;
+var globalVarInitialized2_A = 7;
+class A_A {
+  A_A() {}
+  A_A.fromFoo_A() {}
+  static staticfoo_A() {}
+  foo() {}
+  static const field_A = 5;
+}
 globalfoo() {}
 var globalVar;
 var globalVarInitialized = 6;
 var globalVarInitialized2 = 7;
 class A {
   A() {}
   A.fromFoo() {}
   static staticfoo() {}
   foo() {}
   static const field = 5;
 }
-A_globalfoo() {}
-var A_globalVar;
-var A_globalVarInitialized = 6;
-var A_globalVarInitialized2 = 7;
-class A_A {
-  A_A() {}
-  A_A.A_fromFoo() {}
-  static A_staticfoo() {}
-  foo() {}
-  static const A_field = 5;
-}
 main() {
-  A_globalVar;
-  A_globalVarInitialized;
-  A_globalVarInitialized2;
-  A_globalfoo();
-  A_A.A_field;
-  A_A.A_staticfoo();
-  new A_A();
-  new A_A.A_fromFoo();
-  new A_A().foo();
   globalVar;
   globalVarInitialized;
   globalVarInitialized2;
   globalfoo();
   A.field;
   A.staticfoo();
   new A();
   new A.fromFoo();
   new A().foo();
+  globalVar_A;
+  globalVarInitialized_A;
+  globalVarInitialized2_A;
+  globalfoo_A();
+  A_A.field_A;
+  A_A.staticfoo_A();
+  new A_A();
+  new A_A.fromFoo_A();
+  new A_A().foo();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testNoConflictSendsRename() {
   // Various Send-s to current library and external library. Nothing should be
   // renamed here, only library prefixes must be cut.
   var librarySrc = '''
 library mylib;
 
 globalfoo() {}
 
@@ skipping 59 matching lines @@
   new MyA.myfromFoo();
   new MyA().myfoo();
   globalfoo();
   A.field;
   A.staticfoo();
   new A();
   new A.fromFoo();
   new A().foo();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testConflictLibraryClassRename() {
   var librarySrc = '''
 library mylib;
 
 topfoo() {}
 
 class A {
   foo() {}
@@ skipping 17 matching lines @@
   var b = new A.fromFoo();
   b.foo();
   var GREATVAR = b.myliba;
   b.mylist;
   a = getA();
   topfoo();
   mylib.topfoo();
 }
 ''';
   var expectedResult = '''
-topfoo() {}
+topfoo_A() {}
 class A {
   foo() {}
 }
-A_topfoo() {
+topfoo() {
   var x = 5;
 }
 class A_A {
   num foo() {}
   A_A.fromFoo() {}
   A myliba;
   List<A_A> mylist;
 }
 A getA() => null;
 main() {
   var a = new A();
   a.foo();
   var b = new A_A.fromFoo();
   b.foo();
   var GREATVAR = b.myliba;
   b.mylist;
   a = getA();
-  A_topfoo();
   topfoo();
+  topfoo_A();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testClassExtendsWithArgs() {
   testDart2Dart('''
 main() {
   new B<Object>();
 }
 class A<T extends Object> {}
 class B<T extends Object> extends A<T> {}
 ''');
@@ skipping 22 matching lines @@
 
 main() {
   topgetset;
   topgetset = 6;
 
   mylib.topgetset;
   mylib.topgetset = 5;
 }
 ''';
   var expectedResult = '''
-get topgetset => 5;
+get topgetset_A => 5;
+set topgetset_A(arg) {}
+get topgetset => 6;
 set topgetset(arg) {}
-get A_topgetset => 6;
-set A_topgetset(arg) {}
 main() {
-  A_topgetset;
-  A_topgetset = 6;
   topgetset;
-  topgetset = 5;
+  topgetset = 6;
+  topgetset_A;
+  topgetset_A = 5;
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testFieldTypeOutput() {
   testDart2Dart('''
 main() {
   new A().field;
 }
 class B {}
 class A {
   B field;
@@ skipping 61 matching lines @@
   MyFunction myf1;
   mylib.MyFunction myf2;
   new A<int>().f;
   new T();
 
   new mylib.A<int>().f;
   new mylib.T();
 }
 ''';
   var expectedResult = '''
-typedef void MyFunction<T extends num>(T arg);
+typedef void MyFunction_A<T_B extends num>(T_B arg);
+class T_A {}
+class B_A<T_B> {}
+class A_A<T_B> extends B_A<T_B> {
+  T_B f;
+}
+typedef void MyFunction<T_B extends num>(T_B arg);
 class T {}
-class B<T> {}
-class A<T> extends B<T> {
-  T f;
-}
-typedef void A_MyFunction<A_T extends num>(A_T arg);
-class A_T {}
-class A_B<A_T> {}
-class A_A<A_T> extends A_B<A_T> {
-  A_T f;
+class B<T_B> {}
+class A<T_B> extends B<T_B> {
+  T_B f;
 }
 main() {
-  A_MyFunction myf1;
-  MyFunction myf2;
-  new A_A<int>().f;
-  new A_T();
+  MyFunction myf1;
+  MyFunction_A myf2;
   new A<int>().f;
   new T();
+  new A_A<int>().f;
+  new T_A();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testClassTypeArgumentBound() {
   var librarySrc = '''
 library mylib;
 
 class I {}
 class A<T extends I> {}
 
 ''';
   var mainSrc = '''
 import 'mylib.dart' as mylib;
 
 class I {}
 class A<T extends I> {}
 
 main() {
   new A();
   new mylib.A();
 }
 ''';
   var expectedResult = '''
+class I_A {}
+class A_A<T extends I_A> {}
 class I {}
 class A<T extends I> {}
-class A_I {}
-class A_A<A_T extends A_I> {}
 main() {
+  new A();
   new A_A();
-  new A();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
-}
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
+  }
 
 testDoubleMains() {
   var librarySrc = '''
 library mylib;
 main() {}
 ''';
   var mainSrc = '''
 import 'mylib.dart' as mylib;
 main() {
   mylib.main();
 }
 ''';
   var expectedResult = '''
-A_main() {}
+main_A() {}
 main() {
-  A_main();
+  main_A();
 }
 ''';
-  testDart2DartWithLibrary(mainSrc, librarySrc,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(mainSrc, librarySrc: librarySrc,
+      expectedResult: expectedResult);
 }
 
 testStaticAccessIoLib() {
   var src = '''
 import 'dart:io';
 
 main() {
   Platform.operatingSystem;
 }
 ''';
   var expectedResult = '''
-import "dart:io" as p;
+import "dart:io";
 main() {
-  p.Platform.operatingSystem;
+  Platform.operatingSystem;
 }
 ''';
-  testDart2Dart(src,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(src, expectedResult: expectedResult);
 }
 
 testMinification() {
   var src = '''
 class ClassWithVeryVeryLongName {}
 main() {
   new ClassWithVeryVeryLongName();
 }
 ''';
   var expectedResult =
       'class A{}'
       'main(){new A();}';
-  testDart2Dart(src, continuation:
-      (String result) { Expect.equals(expectedResult, result); }, minify: true);
+  testDart2Dart(src, expectedResult: expectedResult, minify: true);
 }
 
 testClosureLocalsMinified() {
   var src = '''
 main() {
   var a = 7;
   void foo1(a,b) {
     void foo2(c,d) {
        var E = a;
     }
     foo2(b, a);
   }
   foo1(a, 8);
 }
 ''';
   var expectedResult =
       'main(){var A=7; B(A,C){ D(E,F){var G=A;}D(C,A);}B(A,8);}';
-  testDart2Dart(src, continuation:
-      (String result) { Expect.equals(expectedResult, result); }, minify: true);
+  testDart2Dart(src, expectedResult: expectedResult, minify: true);
 }
 
 testParametersMinified() {
   var src = '''
 class A {
   var a;
   static foo(arg1) {
     // Should not rename arg1 to a.
     arg1 = 5;
   }
 }
 
 fooglobal(arg,{optionalarg: 7}) {
   arg = 6;
 }
 
 main() {
   new A().a;
   A.foo(8);
   fooglobal(8);
 }
 ''';
   var expectedResult =
       'class B{var E;static C(A){A=5;}}D(A,{optionalarg: 7}){A=6;}'
       'main(){new B().E;B.C(8);D(8);}';
-  testDart2Dart(src, continuation:
-      (String result) { Expect.equals(expectedResult, result); }, minify: true);
+  testDart2Dart(src, expectedResult: expectedResult, minify: true);
 }
 
 testDeclarationTypePlaceholders() {
   var src = '''
 String globalfield;
 const String globalconstfield;
 
 void foo(String arg) {}
 
 main() {
   String localvar;
   foo("5");
 }
 ''';
   var expectedResult = '''
 foo( arg) {}
 main() {
   var localvar;
   foo("5");
 }
 ''';
-  testDart2Dart(src,
-      continuation: (String result) { Expect.equals(expectedResult, result); },
-      stripTypes: true);
+  testDart2Dart(src, expectedResult: expectedResult, stripTypes: true);
 }
 
 testPlatformLibraryMemberNamesAreFixed() {
   var src = '''
 import 'dart:html';
 
 class A {
   static String get userAgent => window.navigator.userAgent;
 }
 
 main() {
   A.userAgent;
 }
 ''';
   var expectedResult = '''
-import "dart:html" as p;
+import "dart:html";
 class A {
-  static String get A_userAgent => p.window.navigator.userAgent;
+  static String get userAgent_A => window.navigator.userAgent;
 }
 main() {
-  A.A_userAgent;
+  A.userAgent_A;
 }
 ''';
-  testDart2Dart(src,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(src, expectedResult: expectedResult);
 }
 
 testConflictsWithCoreLib() {
   var src = '''
 import 'dart:core' as fisk;
 
 print(x) { throw 'fisk'; }
 
 main() {
   fisk.print('corelib');
   print('local');
 }
 ''';
   var expectedResult = """
-A_print(x) {
+print_A(x) {
   throw 'fisk';
 }
 main() {
   print('corelib');
-  A_print('local');
+  print_A('local');
 }
 """;
-  testDart2Dart(src,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(src, expectedResult: expectedResult);
 }
 
 testUnresolvedNamedConstructor() {
   var src = '''
 class A {
   A() {}
 }
 
 main() {
   new A();
   new A.named();
 }
 ''';
   var expectedResult = """
 class A {
   A() {}
 }
 main() {
   new A();
-  new A_Unresolved();
+  new Unresolved_A();
 }
 """;
-  testDart2Dart(src,
-      continuation: (String result) { Expect.equals(expectedResult, result); });
+  testDart2Dart(src, expectedResult: expectedResult);
 }
 
 main() {
   testSimpleFileUnparse();
   testTopLevelField();
   testSimpleTopLevelClass();
   testClassWithSynthesizedConstructor();
   testClassWithMethod();
   testExtendsImplements();
   testVariableDefinitions();
@@ skipping 12 matching lines @@
   testStaticAccessIoLib();
   testLocalFunctionPlaceholder();
   testMinification();
   testClosureLocalsMinified();
   testParametersMinified();
   testDeclarationTypePlaceholders();
   testPlatformLibraryMemberNamesAreFixed();
   testConflictsWithCoreLib();
   testUnresolvedNamedConstructor();
 }