Merge pull request dart-archive#45 from derekxu16/master

Handled TypeScript utility types and mapped types

Author: derekxu16

lib/base.ts

@@ -239,6 +239,7 @@ export function isTypeNode(node: ts.Node): boolean {
     case ts.SyntaxKind.ArrayType:
     case ts.SyntaxKind.TypeOperator:
     case ts.SyntaxKind.IndexedAccessType:
+    case ts.SyntaxKind.MappedType:
     case ts.SyntaxKind.TypePredicate:
     case ts.SyntaxKind.TypeQuery:
     case ts.SyntaxKind.TupleType:
@@ -332,7 +333,6 @@ export function formatType(s: string, comment: string, options: TypeDisplayOptio
       let expectedStubIndex = result.code.length - stubToMakeTypeValidStatement.length;
       if (result.code.lastIndexOf(stubToMakeTypeValidStatement) === expectedStubIndex) {
         comment = result.code.substring(0, expectedStubIndex).trim();
-        sb += '=';
       }
     }
     sb += comment;

lib/declaration.ts

@@ -565,9 +565,16 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
               base.ident(alias.name), type as ts.FunctionTypeNode, alias.typeParameters);
         } else {
           this.enterCodeComment();
+          if (ts.isMappedTypeNode(alias.type)) {
+            this.emitNoSpace('\n');
+            this.emit(
+                'Warning: Mapped types are not supported in Dart. Uses of this type will be replaced by dynamic.');
+            this.emitNoSpace('\n');
+          }
           this.emit(alias.getText());
+          this.emitNoSpace('\n');
           this.exitCodeComment();
-          this.emit('\n');
+          this.emitNoSpace('\n');
         }
         // We ignore other type alias declarations as Dart doesn't have a corresponding feature yet.
       } break;

lib/facade_converter.ts

@@ -358,6 +358,24 @@ export class FacadeConverter extends base.TranspilerBase {
       const indexTypeName = this.generateDartTypeName(node.indexType, addInsideComment(options));
 
       comment = `${objectTypeName}[${indexTypeName}]`;
+    } else if (ts.isMappedTypeNode(node)) {
+      name = 'dynamic';
+      if (ts.isTypeAliasDeclaration(node.parent)) {
+        // MappedTypeNodes don't contain information about the name or type arguments that were
+        // passed to the alias, so we have to get that information from the parent
+        const parent = node.parent;
+        comment = parent.name.getText();
+        if (parent.typeParameters && options.resolvedTypeArguments) {
+          comment += '<';
+          const resolvedParameters = parent.typeParameters.map(
+              param => this.generateDartTypeName(
+                  options.resolvedTypeArguments.get(base.ident(param.name)), options));
+          for (const resolvedParam of resolvedParameters) {
+            comment += resolvedParam;
+          }
+          comment += '>';
+        }
+      }
     } else if (ts.isTypePredicateNode(node)) {
       name = 'bool';
       comment = base.ident(node.parameterName) + ' is ' +
@@ -387,7 +405,26 @@ export class FacadeConverter extends base.TranspilerBase {
     } else if (ts.isTypePredicateNode(node)) {
       return this.generateDartTypeName(node.type, options);
     } else if (ts.isTypeReferenceNode(node)) {
-      name = this.generateDartName(node.typeName, setTypeArguments(options, node.typeArguments));
+      // First, check for certain TypeScript utility types and handle them manually as continuing to
+      // call generateDartType will try to resolve a type alias that uses the mapped type feature,
+      // which doesn't have a Dart equivalent and will become dynamic
+      // https://www.typescriptlang.org/docs/handbook/utility-types.html
+      const type = node.typeName.getText();
+      switch (type) {
+        case 'Partial':
+          // Partial<X> is currently the same as X since all types are nullable in Dart
+          name = this.generateDartTypeName(node.typeArguments[0]);
+          comment = node.typeName.getText() + '<' +
+              this.generateTypeList(node.typeArguments, addInsideComment(options)) + '>';
+          break;
+        case 'Record':
+          // TODO(derekx): It should be possible to generate a Readonly version of a class by
+          // handling it in the same way as other readonly types. That is, emitting another class
+          // like JS$ReadonlyX whose members don't have setters.
+        default:
+          name =
+              this.generateDartName(node.typeName, setTypeArguments(options, node.typeArguments));
+      }
     } else if (ts.isTypeLiteralNode(node)) {
       let members = node.members;
       if (members.length === 1 && ts.isIndexSignatureDeclaration(members[0])) {

lib/main.ts

@@ -580,8 +580,13 @@ class Output {
     if (!result.error) {
       code = result.code;
     }
-    code = code.trim();
-    this.emitNoSpace(code);
+    const trimmed = code.trim();
+    const isMultilineComment = trimmed.indexOf('\n') !== -1;
+    if (isMultilineComment) {
+      this.emitNoSpace(code);
+    } else {
+      this.emitNoSpace(trimmed);
+    }
     this.emitNoSpace('*/');
 
     // Don't really need an exact column, just need to track

test/function_test.ts

@@ -44,7 +44,7 @@ external f(D fn(C a(B b)));`);
   });
   it('supports generic-typed function parameters', () => {
     expectTranslate('function f<T, U>(fn: (a: T, b: U) => T) {}').to.equal(`@JS()
-external f/*<T, U>*/(dynamic/*=T*/ fn(dynamic/*=T*/ a, dynamic/*=U*/ b));`);
+external f/*<T, U>*/(dynamic /*T*/ fn(dynamic /*T*/ a, dynamic /*U*/ b));`);
   });
   it('translates functions taking rest parameters to untyped Function', () => {
     expectTranslate('function f(fn: (...a: string[]) => number) {}').to.equal(`@JS()
@@ -98,14 +98,14 @@ x({String a, num b, c}) {
 describe('generic functions', () => {
   it('supports generic types', () => {
     expectTranslate('function sort<T, U>(xs: T[]): T[] { return xs; }').to.equal(`@JS()
-external List<dynamic/*=T*/ > sort/*<T, U>*/(List<dynamic/*=T*/ > xs);`);
+external List<dynamic /*T*/ > sort/*<T, U>*/(List<dynamic /*T*/ > xs);`);
   });
   it('replaces type usage sites, but not idents', () => {
     expectTranslate(`function wobble<T, U>(u: U): T { }`).to.equal(`@JS()
-external dynamic/*=T*/ wobble/*<T, U>*/(dynamic/*=U*/ u);`);
+external dynamic /*T*/ wobble/*<T, U>*/(dynamic /*U*/ u);`);
   });
   it('translates generic calls', () => {
     expectTranslate(`function wobble<T>(foo: T): T { }`).to.equal(`@JS()
-external dynamic/*=T*/ wobble/*<T>*/(dynamic/*=T*/ foo);`);
+external dynamic /*T*/ wobble/*<T>*/(dynamic /*T*/ foo);`);
   });
 });

test/js_interop_test.ts

@@ -266,7 +266,7 @@ class X {
 class X<T> {
   // @Ignore
   X.fakeConstructor$();
-  external static X<dynamic/*=T*/ > Z/*<T>*/();
+  external static X<dynamic /*T*/ > Z/*<T>*/();
 }`);
       expectTranslate('class X<T> { Z(): X<T> {} }').to.equal(`@JS()
 class X<T> {
@@ -288,7 +288,7 @@ class X {
   /*external T createElement<T>('img' tagName);*/
   /*external T createElement<T>('video' tagName);*/
   /*external T createElement<T>(String tagName);*/
-  external dynamic/*=T*/ createElement/*<T>*/(
+  external dynamic /*T*/ createElement/*<T>*/(
       String /*'img'|'video'|String*/ tagName);
 }`);
 
@@ -322,7 +322,7 @@ class X {
   /*external T createElement<T extends ImageElement>('img' tagName);*/
   /*external T createElement<T extends VideoElement>('video' tagName);*/
   /*external T createElement<T extends Element>(String tagName);*/
-  external dynamic/*=T*/ createElement/*<T>*/(
+  external dynamic /*T*/ createElement/*<T>*/(
       String /*'img'|'video'|String*/ tagName);
 }`);
 
@@ -936,7 +936,8 @@ function addEventListener(type: string, listener: (this: Element, event: Event)
 
 /*external addEventListener('load' type, void listener(ImageElement JS$this, Event event));*/
 /*external addEventListener(
-    String type, void listener(Element JS$this, Event event));*/
+    String type, void listener(Element JS$this, Event event));
+*/
 @JS()
 external addEventListener(
     String /*'load'|String*/ type, void listener(/*Element this*/ Event event));`);

test/type_test.ts

@@ -96,6 +96,50 @@ external String Function(String) get x;
 @JS()
 external set x(String Function(String) v);`);
   });
+
+  describe('TypeScript utility types and other mapped types', () => {
+    it('emits X in place of Partial<X> since all Dart types are currently nullable', () => {
+      expectTranslate('interface X { a: number; } declare const x: Partial<X>;')
+          .to.equal(`@anonymous
+@JS()
+abstract class X {
+  external num get a;
+  external set a(num v);
+  external factory X({num a});
+}
+
+@JS()
+external X /*Partial<X>*/ get x;`);
+    });
+
+    it('treats other mapped types as dynamic', () => {
+      expectTranslate(`interface Todo {
+        task: string;
+      }
+    
+      type ReadonlyTodo = {
+        readonly[P in keyof Todo]: Todo[P];
+      }
+      
+      declare const todo: ReadonlyTodo;`)
+          .to.equal(`@anonymous
+@JS()
+abstract class Todo {
+  external String get task;
+  external set task(String v);
+  external factory Todo({String task});
+}
+
+/*
+ Warning: Mapped types are not supported in Dart. Uses of this type will be replaced by dynamic.
+ type ReadonlyTodo = {
+        readonly[P in keyof Todo]: Todo[P];
+      }
+*/
+@JS()
+external dynamic /*ReadonlyTodo*/ get todo;`);
+    });
+  });
 });
 
 describe('type arguments', () => {
@@ -239,7 +283,7 @@ external void dispatchSimple(SimpleValueFn<String, num> callback);`);
 `).to.equal(`/*export type Triangle<G> = [G, G, G];*/
 /*export type ListOfLists<G> = [G[]];*/
 @JS()
-external List<List<dynamic/*=T*/ > /*Tuple of <T,T,T>*/ > triangles/*<T>*/();`);
+external List<List<dynamic /*T*/ > /*Tuple of <T,T,T>*/ > triangles/*<T>*/();`);
   });
 
   it('supports the keyof operator and the indexed access operator', () => {
@@ -257,6 +301,6 @@ abstract class A {
 
 @JS()
 external bool f/*<K extends keyof A>*/(
-    dynamic/*=K*/ first, dynamic /*A[K]*/ second);`);
+    dynamic /*K*/ first, dynamic /*A[K]*/ second);`);
   });
 });