Do not emit some unnecessary whitespaces in unparser.

tests/compiler/dart2js/unparser_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 110 matching lines @@
 testForLoop() {
   testUnparse('for(;i<100;i++ ){}');
   testUnparse('for(i=0;i<100;i++ ){}');
 }
 
 testEmptyList() {
   testUnparse('var x=[];');
 }
 
 testClosure() {
-  testUnparse('var x=(var x)=> x;');
+  testUnparse('var x=(var x)=>x;');
 }
 
 testIndexedOperatorDecl() {
-  testUnparseMember('operator[](int i)=> null;');
-  testUnparseMember('operator[]=(int i,int j)=> null;');
+  testUnparseMember('operator[](int i)=>null;');
+  testUnparseMember('operator[]=(int i,int j)=>null;');
 }
 
 testNativeMethods() {
   testUnparseMember('foo()native;');
   testUnparseMember('foo()native "bar";');
   testUnparseMember('foo()native "this.x = 41";');
 }
 
 testPrefixIncrements() {
   testUnparse(' ++i;');
   testUnparse(' ++a[i];');
   testUnparse(' ++a[ ++b[i]];');
 }
 
 testConstModifier() {
-  testUnparse('foo([var a=const []]){}');
+  testUnparse('foo([var a=const[]]){}');
   testUnparse('foo([var a=const{}]){}');
-  testUnparse('foo(){var a=const []; var b=const{};}');
-  testUnparse('foo([var a=const [const{"a": const [1,2,3]}]]){}');
+  testUnparse('foo(){var a=const[];var b=const{};}');
+  testUnparse('foo([var a=const[const{"a":const[1,2,3]}]]){}');
 }
 
 testSimpleFileUnparse() {
   final src = '''
 should_be_dropped() {
 }
 
 should_be_kept() {
 }
 
@@ skipping 16 matching lines @@
 
 testSimpleTopLevelClass() {
   testDart2Dart('main(){new A();}class A{A(){}}');
 }
 
 testClassWithSynthesizedConstructor() {
   testDart2Dart('main(){new A();}class A{}');
 }
 
 testClassWithMethod() {
-  testDart2Dart('main(){var a=new A(); a.foo();}class A{void foo(){}}');
+  testDart2Dart('main(){var a=new A();a.foo();}class A{void foo(){}}');
 }
 
 testExtendsImplements() {
   testDart2Dart('main(){new B<Object>();}'
       'class A<T>{}class B<T> extends A<T>{}');
 }
 
 testVariableDefinitions() {
-  testDart2Dart('main(){final var x,y; final String s;}');
+  testDart2Dart('main(){final var x,y;final String s;}');
   testDart2Dart('foo(f,g){}main(){foo(1,2);}');
   testDart2Dart('foo(f(arg)){}main(){foo(main);}');
   // A couple of static/finals inside a class.
-  testDart2Dart('main(){A.a; A.b;}class A{static const String a="5";'
+  testDart2Dart('main(){A.a;A.b;}class A{static const String a="5";'
       'static const String b="4";}');
   // Class member of typedef-ed function type.
   // Maybe typedef should be included in the result too, but it
   // works fine without it.
   testDart2Dart(
     'typedef void foofunc(arg);main(){new A((arg){});}'
     'class A{A(foofunc this.handler);final foofunc handler;}');
 }
 
 testGetSet() {
   // Top-level get/set.
-  testDart2Dart('set foo(arg){}get foo{return 5;}main(){foo; foo=5;}');
+  testDart2Dart('set foo(arg){}get foo{return 5;}main(){foo;foo=5;}');
   // Field get/set.
-  testDart2Dart('main(){var a=new A(); a.foo; a.foo=5;}'
+  testDart2Dart('main(){var a=new A();a.foo;a.foo=5;}'
       'class A{set foo(a){}get foo{return 5;}}');
   // Typed get/set.
   testDart2Dart('String get foo{return "a";}main(){foo;}');
 }
 
 testFactoryConstructor() {
   testDart2Dart('main(){new A.fromFoo();}class A{A.fromFoo();}');
   // Now more complicated, with normal constructor and factory parameters.
   testDart2Dart('main(){new A.fromFoo(5);}'
       'class A{A(this.f);A.fromFoo(foo):this("f");final String f;}');
   // Now even more complicated, with interface and default factory.
-  testDart2Dart('main(){new A.fromFoo(5); new I.fromFoo();}'
-      'class IFactory{factory I.fromFoo()=> new A(5);}'
+  testDart2Dart('main(){new A.fromFoo(5);new I.fromFoo();}'
+      'class IFactory{factory I.fromFoo()=>new A(5);}'
       'interface I default IFactory{I.fromFoo();}'
       'class A implements I{A(this.f);A.fromFoo(foo):this("f");'
       'final String f;}');
 }
 
 testAbstractClass() {
   testDart2Dart('main(){A.foo;}abstract class A{final static num foo;}');
 }
 
 testConflictSendsRename() {
@@ skipping 50 matching lines @@
   new mylib.A();
   new mylib.A.fromFoo();
   new mylib.A().foo();
 }
 ''';
   var expectedResult =
       'globalfoo(){}var globalVar;var globalVarInitialized=6,globalVarInitialized2=7;'
       'class A{A(){}A.fromFoo(){}static staticfoo(){}foo(){}static const field=5;}'
       'p_globalfoo(){}var p_globalVar;var p_globalVarInitialized=6,p_globalVarInitialized2=7;'
       '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();}';
+      '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); });
 }
 
 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");
 
@@ skipping 34 matching lines @@
   new mylib.A();
   new mylib.A.fromFoo();
   new mylib.A().foo();
 }
 ''';
   var expectedResult =
       '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();}';
+      '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); });
 }
 
 testConflictLibraryClassRename() {
   var librarySrc = '''
 #library('mylib');
 
 topfoo() {}
 
@@ skipping 26 matching lines @@
   a = getA();
   topfoo();
   mylib.topfoo();
 }
 ''';
   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();}';
+    '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); });
 }
 
 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(){}}');
 }
 
@@ skipping 22 matching lines @@
 
 main() {
   topgetset;
   topgetset = 6;
 
   mylib.topgetset;
   mylib.topgetset = 5;
 }
 ''';
   var expectedResult =
-    'get topgetset=> 5;'
+    'get topgetset=>5;'
     'set topgetset(arg){}'
-    'get p_topgetset=> 6;'
+    'get p_topgetset=>6;'
     'set p_topgetset(arg){}'
-    'main(){p_topgetset; p_topgetset=6; topgetset; topgetset=5;}';
+    'main(){p_topgetset;p_topgetset=6;topgetset;topgetset=5;}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       (String result) { Expect.equals(expectedResult, result); });
 }
 
 testFieldTypeOutput() {
   testDart2Dart('main(){new A().field;}class B{}class A{B field;}');
 }
 
 testLocalFunctionPlaceholder() {
   var src = '''
@@ skipping 70 matching lines @@
   new mylib.A();
 }
 ''';
   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();}';
+    'main(){new p_I();new p_A();new I();new A();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       (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 = '''
@@ skipping 22 matching lines @@
 ''';
   var expectedResult =
     'typedef void MyFunction<T extends num>(T arg);'
     '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();}';
+    '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); });
 }
 
 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();}';
+    'main(){new p_A();new A();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       (String result) { Expect.equals(expectedResult, result); });
 }
 
 testDoubleMains() {
   var librarySrc = '''
 #library('mylib');
 main() {}
 ''';
   var mainSrc = '''
@@ skipping 71 matching lines @@
     void foo2(c,d) {
        var E = a;
     }
     foo2(b, a);
   }
   foo1(a, 8);
 }
 ''';
   var expectedResult =
       'main(){'
-        'var a=7; '
+        'var a=7;'
         'void g(a,f){'
           'void c(e,b){'
             'var d=a;'
-          '} '
+          '}'
           'c(f,a);'
-        '} '
+        '}'
         'g(a,8);'
       '}';
   testDart2Dart(src,
       (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 A{var D;static B(b){b=5;}}'
       'C(a,[optionalarg=7]){a=6;}'
-      'main(){new A().D; A.B(8); C(8);}';
+      'main(){new A().D;A.B(8);C(8);}';
   testDart2Dart(src,
       (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');
@@ skipping 30 matching lines @@
 const String globalconstfield;
 
 void foo(String arg) {}
 
 main() {
   String localvar;
   foo("5");
 }
 ''';
   var expectedResult =
-      ' foo( arg){}main(){var localvar; foo("5");}';
+      ' foo( arg){}main(){var localvar;foo("5");}';
   testDart2Dart(src,
       (String result) { Expect.equals(expectedResult, result); },
       cutDeclarationTypes: true);
 }
 
 main() {
   testSignedConstants();
   testGenericTypes();
   testForLoop();
   testEmptyList();
@@ skipping 28 matching lines @@
   testDoubleMains();
   testInterfaceDefaultAnotherLib();
   testStaticAccessIoLib();
   testLocalFunctionPlaceholder();
   testMinification();
   testClosureLocalsMinified();
   testParametersMinified();
   testTypeVariablesInDifferentLibraries();
   testDeclarationTypePlaceholders();
 }