Strip more unused features.

lib/type.ts

Index: lib/type.ts
diff --git a/lib/type.ts b/lib/type.ts
index fa15a61dabc1b59090aeff93b35273828b112cb6..19294a99191bcdd0f06c7cf1f2b6d4b53c8ef887 100644
--- a/lib/type.ts
+++ b/lib/type.ts
@@ -1,37 +1,18 @@
 import * as ts from 'typescript';
+
 import * as base from './base';
+import {FacadeConverter, fixupIdentifierName} from './facade_converter';
 import {Transpiler} from './main';
-import {FacadeConverter} from './facade_converter';
 
 export default class TypeTranspiler extends base.TranspilerBase {
   constructor(tr: Transpiler, private fc: FacadeConverter) { super(tr); }
 
   visitNode(node: ts.Node): boolean {
+    if (base.isTypeNode(node)) {
+      this.emit(this.fc.generateDartTypeName(<ts.TypeNode>node));
+      return true;
+    }
     switch (node.kind) {
-      case ts.SyntaxKind.TypeLiteral:
-        let indexType = this.maybeDestructureIndexType(<ts.TypeLiteralNode>node);
-        if (indexType) {
-          // This is effectively a Map.
-          this.emit('Map <');
-          this.visit(indexType[0]);
-          this.emit(',');
-          this.visit(indexType[1]);
-          this.emit('>');
-        } else {
-          // Dart doesn't support other type literals.
-          this.emit('dynamic');
-        }
-        break;
-      case ts.SyntaxKind.UnionType:
-        this.emit('dynamic /*');
-        this.visitList((<ts.UnionTypeNode>node).types, '|');
-        this.emit('*/');
-        break;
-      case ts.SyntaxKind.TypeReference:
-        let typeRef = <ts.TypeReferenceNode>node;
-        this.fc.visitTypeName(typeRef.typeName);
-        this.maybeVisitTypeArguments(typeRef);
-        break;
       case ts.SyntaxKind.TypeAssertionExpression:
         let typeAssertExpr = <ts.TypeAssertion>node;
         if (this.isReifiedTypeLiteral(typeAssertExpr)) {
@@ -52,27 +33,28 @@ export default class TypeTranspiler extends base.TranspilerBase {
           this.visit(typeParam.constraint);
         }
         break;
-      case ts.SyntaxKind.ArrayType:
-        this.emit('List');
-        this.emit('<');
-        this.visit((<ts.ArrayTypeNode>node).elementType);
-        this.emit('>');
-        break;
-      case ts.SyntaxKind.FunctionType:
-        this.emit('dynamic /*');
-        this.emit(node.getText());
-        this.emit('*/');
-        break;
       case ts.SyntaxKind.QualifiedName:
+        // TODO(jacobr): there is overlap between this case and
+        // generateDartTypeName in facade_converter.
         let first = <ts.QualifiedName>node;
+        let match = this.fc.lookupCustomDartTypeName(first);
+        if (match) {
+          this.emit(match.name);
+          if (match.comment) {
+            this.emit('/* ' + match.comment + '*/');
+          }
+          break;
+        }
         this.visit(first.left);
         this.emit('.');
         this.visit(first.right);
         break;
       case ts.SyntaxKind.Identifier:
         let ident = <ts.Identifier>node;
-        this.fc.visitTypeName(ident);
+        let text = fixupIdentifierName(ident.text);
+        this.emit(text);
         break;
+      // TODO(jacobr): all these cases might be obsolete.
       case ts.SyntaxKind.NumberKeyword:
         this.emit('num');
         break;