Second round of cleanups for new optional parameter semantics.

tests/compiler/dart2js/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('dart:uri');
 #import('parser_helper.dart');
 #import('mock_compiler.dart');
 #import("../../../lib/compiler/compiler.dart");
 #import("../../../lib/compiler/implementation/leg.dart", prefix:'leg');
 #import("../../../lib/compiler/implementation/dart_backend/dart_backend.dart");
@@ skipping 36 matching lines @@
 }
 abstract class Navigator {
   abstract String get userAgent;
 }
 ''';
 
 const helperLib = r'''
 #library('js_helper');
 ''';
 
-testDart2Dart(String src, [void continuation(String s), bool minify = false,
-    bool stripTypes = false]) {
+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, minify, stripTypes);
+  testDart2DartWithLibrary(src, '', continuation: continuation, minify: minify,
+      stripTypes: stripTypes);

[Lasse Reichstein Nielsen, 2012/10/17 14:56:10]

This is one of the cases where we would really want to use both optional
positional and optional named parameters on the same function. It really should
be allowed.

[regis, 2012/10/17 19:58:16]

Agreed.

 }
 
 /**
  * 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]) {
+    {void continuation(String s), bool minify: false,
+    bool stripTypes: false}) {
   fileUri(path) => new Uri.fromComponents(scheme: 'file', path: path);
 
   final scriptUri = fileUri('script.dart');
   final libUri = fileUri('mylib.dart');
 
   provider(uri) {
     if (uri == scriptUri) return new Future.immediate(srcMain);
     if (uri.toString() == libUri.toString()) {
       return new Future.immediate(srcLibrary);
     }
@@ skipping 29 matching lines @@
 should_be_dropped() {
 }
 
 should_be_kept() {
 }
 
 main() {
   should_be_kept();
 }
 ''';
-  testDart2Dart(src, (String s) {
+  testDart2Dart(src, continuation: (String s) {
     Expect.equals('should_be_kept(){}main(){should_be_kept();}', s);
   });
 }
 
 testTopLevelField() {
   testDart2Dart('final String x="asd";main(){x;}');
 }
 
 testSimpleTopLevelClass() {
   testDart2Dart('main(){new A();}class A{A(){}}');
@@ skipping 120 matching lines @@
       'class p_A{p_A(){}p_A.fromFoo(){}static p_staticfoo(){}foo(){}'
           'static const p_field=5;}'
       'main(){p_globalVar;p_globalVarInitialized;'
          'p_globalVarInitialized2;p_globalfoo();'
          'p_A.p_field;p_A.p_staticfoo();'
          'new p_A();new p_A.fromFoo();new p_A().foo();'
          'globalVar;globalVarInitialized;globalVarInitialized2;globalfoo();'
          'A.field;A.staticfoo();'
          'new A();new A.fromFoo();new A().foo();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 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.dart");
 
 globalfoo() {}
 
@@ skipping 38 matching lines @@
       'globalfoo(){}'
       'class A{A(){}A.fromFoo(){}static staticfoo(){}foo(){}'
           'static const field=5;}'
       'myglobalfoo(){}'
       'class MyA{MyA(){}MyA.myfromFoo(){}static mystaticfoo(){}myfoo(){}'
           'static const myfield=5;}'
       'main(){myglobalfoo();MyA.myfield;MyA.mystaticfoo();new MyA();'
           'new MyA.myfromFoo();new MyA().myfoo();globalfoo();A.field;'
           'A.staticfoo();new A();new A.fromFoo();new A().foo();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testConflictLibraryClassRename() {
   var librarySrc = '''
 #library('mylib');
 
 topfoo() {}
 
 class A {
   foo(){}
@@ skipping 28 matching lines @@
 ''';
   var expectedResult =
     'topfoo(){}'
     'class A{foo(){}}'
     'p_topfoo(){var x=5;}'
     'class p_A{num foo(){}p_A.fromFoo(){}A myliba;List<p_A> mylist;}'
     'A getA()=>null;'
     'main(){var a=new A();a.foo();var b=new p_A.fromFoo();b.foo();'
         'var GREATVAR=b.myliba;b.mylist;a=getA();p_topfoo();topfoo();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testDefaultClassWithArgs() {
   testDart2Dart('main(){var result=new IA<String>();}'
       'interface IA<T> default A<T extends Object>{IA();}'
       'class A<T extends Object> implements IA<T>{factory A(){}}');
 }
 
 testClassExtendsWithArgs() {
   testDart2Dart('main(){new B<Object>();}'
@@ skipping 26 matching lines @@
   mylib.topgetset = 5;
 }
 ''';
   var expectedResult =
     'get topgetset=>5;'
     'set topgetset(arg){}'
     'get p_topgetset=>6;'
     'set p_topgetset(arg){}'
     'main(){p_topgetset;p_topgetset=6;topgetset;topgetset=5;}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testFieldTypeOutput() {
   testDart2Dart('main(){new A().field;}class B{}class A{B field;}');
 }
 
 class DynoMap implements Map<Element, ElementAst> {
   final compiler;
   DynoMap(this.compiler);
 
@@ skipping 78 matching lines @@
 ''';
   var expectedResult =
     'interface I default B{I();}'
     'class A implements I{A(){}}'
     'class B{factory I(){}}'
     'interface p_I default p_B{p_I();}'
     'class p_A implements p_I{p_A(){}}'
     'class p_B{factory p_I(){}}'
     'main(){new p_I();new p_A();new I();new A();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testTypeVariablesAreRenamed() {
   // Somewhat a hack: we require all the references of the identifier
   // to be renamed in the same way for the whole library. Hence
   // if we have a class and type variable with the same name, they
   // both should be renamed.
   var librarySrc = '''
 #library('mylib');
 typedef void MyFunction<T extends num>(T arg);
@@ skipping 23 matching lines @@
     'class T{}'
     'class B<T>{}'
     'class A<T> extends B<T>{T f;}'
     'typedef void p_MyFunction<p_T extends num>(p_T arg);'
     'class p_T{}'
     'class p_B<p_T>{}'
     'class p_A<p_T> extends p_B<p_T>{p_T f;}'
     'main(){p_MyFunction myf1;MyFunction myf2;new p_A<int>().f;'
         'new p_T();new A<int>().f;new T();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testClassTypeArgumentBound() {
   var librarySrc = '''
 #library('mylib');
 
 interface I {}
 class A<T extends I> {}
 
 ''';
   var mainSrc = '''
 #import('mylib.dart', prefix: 'mylib');
 
 interface I {}
 class A<T extends I> {}
 
 main() {
   new A();
   new mylib.A();
 }
 ''';
   var expectedResult =
     'interface I{}'
     'class A<T extends I>{}'
     'interface p_I{}'
     'class p_A<p_T extends p_I>{}'
     'main(){new p_A();new A();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testDoubleMains() {
   var librarySrc = '''
 #library('mylib');
 main() {}
 ''';
   var mainSrc = '''
 #import('mylib.dart', prefix: 'mylib');
 main() {
   mylib.main();
 }
 ''';
   var expectedResult =
     'p_main(){}'
     'main(){p_main();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testInterfaceDefaultAnotherLib() {
   var librarySrc = '''
 #library('mylib');
 class C<T> {
   factory I() {}
 }
 ''';
   var mainSrc = '''
 #import('mylib.dart', prefix: 'mylib');
 
 interface I<T> default mylib.C<T> {
   I();
 }
 
 main() {
   new I();
 }
 ''';
   var expectedResult =
     'class C<T>{factory I(){}}'
     'interface I<T> default C<T>{I();}'
     'main(){new I();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testStaticAccessIoLib() {
   var src = '''
 #import('dart:io');
 
 main() {
   Platform.operatingSystem;
 }
 ''';
   var expectedResult = 'import "dart:io" as p;'
       'main(){p.Platform.operatingSystem;}';
   testDart2Dart(src,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testMinification() {
   var src = '''
 class ClassWithVeryVeryLongName {}
 main() {
   new ClassWithVeryVeryLongName();
 }
 ''';
   var expectedResult =
       'class A{}'
       'main(){new A();}';
-  testDart2Dart(src,
+  testDart2Dart(src, continuation:
       (String result) { Expect.equals(expectedResult, result); }, 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,
+  testDart2Dart(src, continuation:
       (String result) { Expect.equals(expectedResult, result); }, 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,
+  testDart2Dart(src, continuation:
       (String result) { Expect.equals(expectedResult, result); }, minify: true);
 }
 
 testTypeVariablesInDifferentLibraries() {
 // This is a simplified version of what we have in
 // lib/compiler/implementation/util.
   var librarySrc = '''
 #library('mylib');
 #import('script.dart');
 interface Iterable<K> {}
@@ skipping 13 matching lines @@
 main() {
   new Link<int>();
 }
 ''';
   var expectedResult =
     'interface Iterable<K>{}'
     'interface Link<T> extends Iterable<T> default LinkFactory<T>{Link();}'
     'class LinkFactory<T>{factory Link(){}}'
     'main(){new Link<int>();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 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,
-      (String result) { Expect.equals(expectedResult, result); },
+      continuation: (String result) { Expect.equals(expectedResult, result); },
       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;'
       'class A{static String get userAgent=>p.window.navigator.userAgent;}'
       'main(){A.userAgent;}';
   testDart2Dart(src,
-      (String result) { Expect.equals(expectedResult, result); });
+      continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 main() {
   testSimpleFileUnparse();
   testTopLevelField();
   testSimpleTopLevelClass();
   testClassWithSynthesizedConstructor();
   testClassWithMethod();
   testExtendsImplements();
   testVariableDefinitions();
@@ skipping 16 matching lines @@
   testInterfaceDefaultAnotherLib();
   testStaticAccessIoLib();
   testLocalFunctionPlaceholder();
   testMinification();
   testClosureLocalsMinified();
   testParametersMinified();
   testTypeVariablesInDifferentLibraries();
   testDeclarationTypePlaceholders();
   testPlatformLibraryMemberNamesAreFixed();
 }