Integrate Dart Formatter directly into ts2dart for cleaner output

and more readable test cases.

Author: jacob314

gulpfile.js

@@ -12,6 +12,7 @@ var sourcemaps = require('gulp-sourcemaps');
 var spawn = require('child_process').spawn;
 var ts = require('gulp-typescript');
 var typescript = require('typescript');
+var style = require('dart-style');
 var which = require('which');
 
 gulp.task('test.check-format', function() {
@@ -54,7 +55,10 @@ gulp.task('test.compile', ['compile'], function(done) {
     done();
     return;
   }
-  return gulp.src(['test/*.ts', 'typings/**/*.d.ts'], {base: '.'})
+  return gulp
+      .src(
+          ['test/*.ts', 'typings/**/*.d.ts', 'node_modules/dart-style/dart-style.d.ts'],
+          {base: '.'})
       .pipe(sourcemaps.init())
       .pipe(ts(tsProject))
       .on('error', onError)
@@ -84,7 +88,7 @@ gulp.task('test.e2e', ['test.compile'], function(done) {
 
   // run node with a shell so we can wildcard all the .ts files
   var cmd = 'node ../lib/main.js --translateBuiltins --basePath=. --destination=. ' +
-            '*.ts angular2/src/facade/lang.d.ts';
+      '*.ts angular2/src/facade/lang.d.ts';
   // Paths must be relative to our source root, so run with cwd == dir.
   spawn('sh', ['-c', cmd], {stdio: 'inherit', cwd: dir}).on('close', function(code, signal) {
     if (code > 0) {

lib/base.ts

@@ -63,10 +63,10 @@ export class TranspilerBase {
 
   isConst(decl: ClassLike) {
     return this.hasAnnotation(decl.decorators, 'CONST') ||
-           (<ts.NodeArray<ts.Declaration>>decl.members).some((m) => {
-             if (m.kind !== ts.SyntaxKind.Constructor) return false;
-             return this.hasAnnotation(m.decorators, 'CONST');
-           });
+        (<ts.NodeArray<ts.Declaration>>decl.members).some((m) => {
+          if (m.kind !== ts.SyntaxKind.Constructor) return false;
+          return this.hasAnnotation(m.decorators, 'CONST');
+        });
   }
 
   getRelativeFileName(fileName: string): string {

lib/expression.ts

@@ -24,6 +24,8 @@ export default class ExpressionTranspiler extends base.TranspilerBase {
           if (operatorKind === ts.SyntaxKind.InstanceOfKeyword) {
             this.emit('is');
             this.fc.visitTypeName(<ts.Identifier>binExpr.right);
+          } else if (operatorKind == ts.SyntaxKind.InKeyword) {
+            this.reportError(node, 'in operator is unsupported');
           } else {
             this.emit(ts.tokenToString(binExpr.operatorToken.kind));
             this.visit(binExpr.right);

lib/facade_converter.ts

@@ -197,7 +197,7 @@ export class FacadeConverter extends base.TranspilerBase {
   private reportMissingType(n: ts.Node, ident: string) {
     this.reportError(
         n, `Untyped property access to "${ident}" which could be ` + `a special ts2dart builtin. ` +
-               `Please add type declarations to disambiguate.`);
+            `Please add type declarations to disambiguate.`);
   }
 
   isInsideConstExpr(node: ts.Node): boolean {

lib/main.ts

@@ -14,6 +14,7 @@ import StatementTranspiler from './statement';
 import TypeTranspiler from './type';
 import LiteralTranspiler from './literal';
 import {FacadeConverter} from './facade_converter';
+import * as dartStyle from 'dart-style';
 
 export interface TranspilerOptions {
   /**
@@ -173,7 +174,16 @@ export class Transpiler {
         new Output(sourceFile, this.getRelativeFileName(), this.options.generateSourceMap);
     this.lastCommentIdx = -1;
     this.visit(sourceFile);
-    return this.output.getResult();
+    var result = this.output.getResult();
+    return this.formatCode(result, sourceFile);
+  }
+
+  private formatCode(code: string, context: ts.Node) {
+    var result = dartStyle.formatCode(code);
+    if (result.error) {
+      this.reportError(context, result.error);
+    }
+    return result.code;
   }
 
   private checkForErrors(program: ts.Program) {
@@ -325,7 +335,7 @@ class Output {
     }
   }
 
-  getResult(): string { return this.result + this.generateSourceMapComment(); }
+  getResult(): string { return this.result; }
 
   addSourceMapping(n: ts.Node) {
     if (!this.sourceMap) return;  // source maps disabled.

package.json

@@ -8,14 +8,15 @@
     "test": "test"
   },
   "dependencies": {
+    "dart-style": "^0.2.6",
     "minimist": "^1.1.1",
     "source-map": "^0.4.2",
     "source-map-support": "^0.3.1",
     "typescript": "mprobst/TypeScript#pathMappingModuleResolution"
   },
   "devDependencies": {
     "chai": "^2.1.1",
-    "clang-format": "^1.0.25",
+    "clang-format": "^1.0.34",
     "fs-extra": "^0.18.0",
     "gulp": "^3.8.11",
     "gulp-clang-format": "^1.0.21",

test/call_test.ts

@@ -4,50 +4,59 @@ import {expectTranslate, expectErroneousCode} from './test_support';
 describe('calls', () => {
   it('translates destructuring parameters', () => {
     expectTranslate('function x({p = null, d = false} = {}) {}')
-        .to.equal(' x ( { p : null , d : false } ) { }');
+        .to.equal('x({p: null, d: false}) {}');
     expectErroneousCode('function x({a=false}={a:true})')
         .to.throw('initializers for named parameters must be empty object literals');
     expectErroneousCode('function x({a=false}=true)')
         .to.throw('initializers for named parameters must be empty object literals');
-    expectTranslate('class X { constructor() { super({p: 1}); } }')
-        .to.equal(
-            ' class X { X ( ) : super ( p : 1 ) {' +
-            ' /* super call moved to initializer */ ; } }');
+    expectTranslate('class X { constructor() { super({p: 1}); } }').to.equal(`class X {
+  X() : super(p: 1) {
+    /* super call moved to initializer */;
+  }
+}`);
   });
   it('hacks last object literal parameters into named parameter', () => {
-    expectTranslate('f(x, {a: 12, b: 4});').to.equal(' f ( x , a : 12 , b : 4 ) ;');
-    expectTranslate('f({a: 12});').to.equal(' f ( a : 12 ) ;');
-    expectTranslate('f({"a": 12});').to.equal(' f ( { "a" : 12 } ) ;');
-    expectTranslate('new X(x, {a: 12, b: 4});').to.equal(' new X ( x , a : 12 , b : 4 ) ;');
-    expectTranslate('f(x, {});').to.equal(' f ( x , { } ) ;');
+    expectTranslate('f(x, {a: 12, b: 4});').to.equal('f(x, a: 12, b: 4);');
+    expectTranslate('f({a: 12});').to.equal('f(a: 12);');
+    expectTranslate('f({"a": 12});').to.equal('f({"a": 12});');
+    expectTranslate('new X(x, {a: 12, b: 4});').to.equal('new X(x, a: 12, b: 4);');
+    expectTranslate('f(x, {});').to.equal('f(x, {});');
   });
   it('translates calls', () => {
-    expectTranslate('foo();').to.equal(' foo ( ) ;');
-    expectTranslate('foo(1, 2);').to.equal(' foo ( 1 , 2 ) ;');
+    expectTranslate('foo();').to.equal('foo();');
+    expectTranslate('foo(1, 2);').to.equal('foo(1, 2);');
   });
   it('translates new calls', () => {
-    expectTranslate('new Foo();').to.equal(' new Foo ( ) ;');
-    expectTranslate('new Foo(1, 2);').to.equal(' new Foo ( 1 , 2 ) ;');
-    expectTranslate('new Foo<number, string>(1, 2);')
-        .to.equal(' new Foo < num , String > ( 1 , 2 ) ;');
+    expectTranslate('new Foo();').to.equal('new Foo();');
+    expectTranslate('new Foo(1, 2);').to.equal('new Foo(1, 2);');
+    expectTranslate('new Foo<number, string>(1, 2);').to.equal('new Foo<num, String>(1, 2);');
   });
   it('throws away generic type parameters',
-     () => { expectTranslate('var s = foo<string>();').to.equal(' var s = foo ( ) ;'); });
+     () => { expectTranslate('var s = foo<string>();').to.equal('var s = foo();'); });
   it('translates "super()" constructor calls', () => {
-    expectTranslate('class X { constructor() { super(1); } }')
-        .to.equal(' class X { X ( ) : super ( 1 ) { /* super call moved to initializer */ ; } }');
+    expectTranslate('class X { constructor() { super(1); } }').to.equal(`class X {
+  X() : super(1) {
+    /* super call moved to initializer */;
+  }
+}`);
     expectErroneousCode('class X { constructor() { if (y) super(1, 2); } }')
         .to.throw('super calls must be immediate children of their constructors');
-    expectTranslate('class X { constructor() { a(); super(1); b(); } }')
-        .to.equal(
-            ' class X { X ( ) : super ( 1 ) {' +
-            ' a ( ) ; /* super call moved to initializer */ ; b ( ) ;' +
-            ' } }');
+    expectTranslate('class X { constructor() { a(); super(1); b(); } }').to.equal(`class X {
+  X() : super(1) {
+    a();
+    /* super call moved to initializer */
+    ;
+    b();
+  }
+}`);
   });
   it('translates "super.x()" super method calls', () => {
-    expectTranslate('class X { y() { super.z(1); } }')
-        .to.equal(' class X { y ( ) { super . z ( 1 ) ; } }');
+    expectTranslate('class X { y() { super.z(1); } }').to.equal(`class X {
+  y() {
+    super.z(1);
+  }
+}`);
   });
   it('transpiles new calls without arguments',
-     () => { expectTranslate('new Foo;').to.equal(' new Foo ( ) ;'); });
+     () => { expectTranslate('new Foo;').to.equal('new Foo();'); });
 });