JS Interop Facade generation polish.

lib/declaration.ts

 import * as ts from 'typescript';
 
 import * as base from './base';
 import {FacadeConverter} from './facade_converter';
 import {Transpiler} from './main';
-import {MergedParameter, MergedType} from './merge';
+import {MergedParameter, MergedType, MergedTypeParameters} from './merge';
 
 export function isFunctionLikeProperty(
     decl: ts.PropertyDeclaration|ts.ParameterDeclaration, tc: ts.TypeChecker): boolean {
   if (!decl.type) return false;
+  if (decl.name.kind !== ts.SyntaxKind.Identifier) {
+    // No need to promote properties
+    return false;
+  }
   let name = base.ident(decl.name);
   if (name.match(/^on[A-Z]/)) return false;
   return base.isFunctionType(decl.type, tc);
 }
 
 export default class DeclarationTranspiler extends base.TranspilerBase {
   private tc: ts.TypeChecker;
 
-  private moduleStack: string[] = [];
   private extendsClass: boolean = false;
 
   static NUM_FAKE_REST_PARAMETERS = 5;
 
   setTypeChecker(tc: ts.TypeChecker) { this.tc = tc; }
   setFacadeConverter(fc: FacadeConverter) { this.fc = fc; }
 
-  getJsPath(node: ts.Node): string {
-    let path = [].concat(this.moduleStack);
+  getJsPath(node: ts.Node, suppressUnneededPaths = true): string {
+    let path: Array<String> = [];
+    let moduleDecl =
+        base.getAncestor(node, ts.SyntaxKind.ModuleDeclaration) as ts.ModuleDeclaration;
+    while (moduleDecl != null) {
+      path.unshift(moduleDecl.name.text);
+      moduleDecl =
+          base.getAncestor(
+                  moduleDecl.parent, ts.SyntaxKind.ModuleDeclaration) as ts.ModuleDeclaration;
+    }
+
     let classDecl = base.getEnclosingClass(node);
     if (classDecl) {
-      path.push(classDecl.name.text);
+      if (classDecl.kind === ts.SyntaxKind.InterfaceDeclaration) {
+        let interfaceDecl = classDecl as base.ExtendedInterfaceDeclaration;
+        if (interfaceDecl.classLikeVariableDeclaration) {
+          // We upgrade these variable interface declarations to behave more
+          // like class declarations as we have a valid concrete JS class to
+          // an appropriate class object.
+          return this.getJsPath(interfaceDecl.classLikeVariableDeclaration, false);
+        }
+        return '';
+      } else {
+        path.push(classDecl.name.text);
+      }
     }
 
     switch (node.kind) {
       case ts.SyntaxKind.ModuleDeclaration:
+        path.push((<ts.ModuleDeclaration>node).name.text);
         break;
       case ts.SyntaxKind.ClassDeclaration:
       case ts.SyntaxKind.InterfaceDeclaration:
-        path.push((<base.ClassLike>node).name.text);
+        // Already handled by call to getEnclosingClass.
         break;
       case ts.SyntaxKind.EnumDeclaration:
         path.push((<ts.EnumDeclaration>node).name.text);
         break;
       case ts.SyntaxKind.PropertyDeclaration:
       case ts.SyntaxKind.VariableDeclaration:
       case ts.SyntaxKind.MethodDeclaration:
+      case ts.SyntaxKind.MethodSignature:
       case ts.SyntaxKind.FunctionDeclaration:
       case ts.SyntaxKind.GetAccessor:
       case ts.SyntaxKind.SetAccessor:
       case ts.SyntaxKind.PropertySignature:
         let memberName = base.ident((<base.NamedDeclaration>node).name);
         if (!base.isStatic(node) && classDecl != null) return memberName;
         path.push(memberName);
         break;
       default:
         throw 'Internal error. Unexpected node kind:' + node.kind;
     }
-    if (path.length === 1) {
-      // No need to specify the path if is simply the node name.
+    if (suppressUnneededPaths && path.length === 1) {
+      // No need to specify the path if is simply the node name or the escaped version of the node
+      // name.
       return '';
     }
     return path.join('.');
   }
 
   private isAnonymousInterface(node: ts.Node): boolean {
     if (node.kind !== ts.SyntaxKind.InterfaceDeclaration) return false;
-    // This is a bit of a hack but for the purposes of Dart codegen,
-    // interfaces with static members or constructors have a known class name
-    // at least for the purposes of resolving static members.
-    // Example case that triggers this case:
-    // interface Foo {
-    //   bar();
-    // }
-    // declare let Foo: {
-    //   new(): Foo,
-    //   SOME_STATIC : number;
-    // }
-    return (<ts.InterfaceDeclaration>node).members.every((m: ts.Declaration) => {
-      return m.kind !== ts.SyntaxKind.Constructor && !base.isStatic(m);
-    });
+    let interfaceDecl = node as base.ExtendedInterfaceDeclaration;
+    // If we were able to associate a variable declaration with the interface definition then
+    // the interface isn't actually anonymous.
+    return !interfaceDecl.classLikeVariableDeclaration;
   }
 
   maybeEmitJsAnnotation(node: ts.Node) {
     // No need to emit the annotations as an entity outside the code comment
     // will already have the same annotation.
     if (this.insideCodeComment) return;
 
     if (this.isAnonymousInterface(node)) {
       this.emit('@anonymous');
       this.emit('@JS()');
       return;
     }
     let name: String = this.getJsPath(node);
     this.emit('@JS(');
     if (name.length > 0) {
       this.emit('"' + name + '"');
     }
     this.emit(')');
   }
 
   /**
    * Emit fake constructors to placate the Dart Analyzer for JS Interop classes.
    */
-  maybeEmitFakeConstructors(decl: base.ClassLike) {
+  maybeEmitFakeConstructors(decl: ts.Node) {
     if (decl.kind === ts.SyntaxKind.ClassDeclaration) {
       // Required to avoid spurious dart errors involving base classes without
       // default constructors.
       this.emit('// @Ignore\n');
-      this.fc.visitTypeName(decl.name);
+      this.fc.visitTypeName((<ts.ClassDeclaration>decl).name);
       this.emit('.fakeConstructor$()');
       if (this.extendsClass) {
         // Required to keep the Dart Analyzer happy when a class has subclasses.
         this.emit(': super.fakeConstructor$()');
       }
       this.emit(';\n');
     }
   }
 
   private visitName(name: ts.Node) {
     if (base.getEnclosingClass(name) != null) {
       this.visit(name);
       return;
     }
     // Have to rewrite names in this case as we could have conflicts
     // due to needing to support multiple JS modules in a single JS module
     if (name.kind !== ts.SyntaxKind.Identifier) {
       throw 'Internal error: unexpected function name kind:' + name.kind;
     }
-    let entry = this.fc.lookupCustomDartTypeName(<ts.Identifier>name, this.insideCodeComment);
+    let entry = this.fc.lookupCustomDartTypeName(<ts.Identifier>name);
     if (entry) {
       this.emit(entry.name);
       return;
     }
 
     this.visit(name);
   }
 
   private notSimpleBagOfProperties(type: ts.Type): boolean {
     if (this.tc.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) return true;
@@ skipping 20 matching lines @@
     return false;
   }
 
   /**
    * Returns whether all members of the class and all base classes
    */
   hasOnlyProperties(decl: ts.InterfaceDeclaration, outProperties: ts.PropertyDeclaration[]):
       boolean {
     let type = <ts.InterfaceType>this.tc.getTypeAtLocation(decl);
 
-    let properties = this.tc.getPropertiesOfType(type);
+    let symbols = this.tc.getPropertiesOfType(type);
     let baseTypes = this.tc.getBaseTypes(type);
     if (this.notSimpleBagOfProperties(type)) return false;
     for (let i = 0; i < baseTypes.length; ++i) {
       let baseType = baseTypes[i];
       if (this.notSimpleBagOfProperties(baseType)) return false;
     }
 
+    let properties: ts.Declaration[] = [];
+
+    for (let i = 0; i < symbols.length; ++i) {
+      let symbol = symbols[i];
+      let property = symbol.valueDeclaration;
+      properties.push(property);
+    }
+    return this.hasOnlyPropertiesHelper(properties, outProperties);
+  }
+
+  hasOnlyPropertiesHelper(properties: ts.Declaration[], outProperties: ts.Declaration[]): boolean {
     for (let i = 0; i < properties.length; ++i) {
-      let symbol = properties[i];
-      let node = symbol.valueDeclaration;
+      let node = properties[i];
       switch (node.kind) {
         case ts.SyntaxKind.PropertyDeclaration:
         case ts.SyntaxKind.PropertySignature:
         case ts.SyntaxKind.VariableDeclaration:
           let prop = <ts.PropertyDeclaration>node;
           if (this.promoteFunctionLikeMembers && isFunctionLikeProperty(prop, this.tc)) {
             return false;
           }
           outProperties.push(prop);
           break;
         default:
           return false;
       }
     }
     return outProperties.length > 0;
   }
 
-  visitClassBody(decl: base.ClassLike) {
+  visitClassBody(decl: base.ClassLike|ts.TypeLiteralNode, name: ts.Identifier) {
     let properties: ts.PropertyDeclaration[] = [];
-    let isPropertyBag = decl.kind === ts.SyntaxKind.InterfaceDeclaration &&
-        this.hasOnlyProperties(<ts.InterfaceDeclaration>decl, properties);
+    let isPropertyBag = false;
+    if (decl.kind === ts.SyntaxKind.InterfaceDeclaration) {
+      isPropertyBag = this.hasOnlyProperties(<ts.InterfaceDeclaration>decl, properties);
+    } else if (decl.kind === ts.SyntaxKind.TypeLiteral) {
+      isPropertyBag = this.hasOnlyPropertiesHelper(decl.members, properties);
+    }
     this.visitMergingOverloads(decl.members);
 
     if (isPropertyBag) {
       this.emit('external factory');
-      this.fc.visitTypeName(decl.name);
+      this.fc.visitTypeName(name);
       this.emitNoSpace('({');
       for (let i = 0; i < properties.length; i++) {
         if (i > 0) this.emitNoSpace(',');
         let p = properties[i];
         this.visit(p.type);
         this.visit(p.name);
       }
       this.emitNoSpace('});');
     }
   }
@@ skipping 50 matching lines @@
         case ts.SyntaxKind.Constructor:
           break;
         case ts.SyntaxKind.ConstructSignature:
           break;
         case ts.SyntaxKind.IndexSignature:
           name = '[]';
           break;
         case ts.SyntaxKind.ClassDeclaration:
         case ts.SyntaxKind.InterfaceDeclaration:
         case ts.SyntaxKind.VariableStatement:
-          orderedGroups.push([node]);
-          return;
         case ts.SyntaxKind.GetAccessor:
         case ts.SyntaxKind.SetAccessor:
         case ts.SyntaxKind.SemicolonClassElement:
         case ts.SyntaxKind.ModuleDeclaration:
         case ts.SyntaxKind.TypeAliasDeclaration:
         case ts.SyntaxKind.ExportAssignment:
+        case ts.SyntaxKind.EnumDeclaration:
+        case ts.SyntaxKind.ImportDeclaration:
+        case ts.SyntaxKind.ExportDeclaration:
+        case ts.SyntaxKind.GlobalModuleExportDeclaration:
+        case ts.SyntaxKind.ImportEqualsDeclaration:
+        case ts.SyntaxKind.EmptyStatement:
+        case ts.SyntaxKind.ExpressionStatement:
+          // Types where we don't need to perform any merging overloads work.
           orderedGroups.push([node]);
           return;
         default:
-          console.log('Warning: unexpected type... overloads: ' + node.kind + ' ' + node.getText());
+          // This warning is to make sure we aren't quietly missing a type we need to perform
+          // overload chunking and merging on.
+          console.log(
+              'Warning: unexpected type found looking for overloads: ' + node.kind + ' ' +
+              node.getText());
           orderedGroups.push([node]);
           return;
       }
       let group: Array<ts.Node>;
       if (Object.prototype.hasOwnProperty.call(groups, name)) {
         group = groups[name];
       } else {
         group = [];
         groups[name] = group;
         orderedGroups.push(group);
@@ skipping 38 matching lines @@
         case ts.SyntaxKind.IndexSignature:
           break;
         default:
           throw 'Unexpected kind:' + kind;
       }
       let mergedParams = first.parameters.map(
           (param: ts.ParameterDeclaration) => new MergedParameter(param, this.fc));
       let mergedType = new MergedType(this.fc);
       mergedType.merge(first.type);
 
+      let mergedTypeParams = new MergedTypeParameters(this.fc);
+      mergedTypeParams.merge(first.typeParameters);
+
       for (let i = 1; i < group.length; ++i) {
         let signature = <ts.SignatureDeclaration>group[i];
         mergedType.merge(signature.type);
+        mergedTypeParams.merge(signature.typeParameters);
         let overlap = Math.min(signature.parameters.length, mergedParams.length);
         for (let j = 0; j < overlap; ++j) {
           mergedParams[j].merge(signature.parameters[j]);
         }
         for (let j = overlap; j < mergedParams.length; ++j) {
           mergedParams[j].setOptional();
         }
         for (let j = mergedParams.length; j < signature.parameters.length; ++j) {
           let param = new MergedParameter(signature.parameters[j], this.fc);
           param.setOptional();
           mergedParams.push(param);
         }
       }
       merged.parameters = <ts.NodeArray<ts.ParameterDeclaration>>mergedParams.map(
           (p) => p.toParameterDeclaration());
       merged.type = mergedType.toTypeNode();
+      merged.typeParameters = mergedTypeParams.toTypeParameters();
 
       this.fc.visit(merged);
     });
   }
 
 
   constructor(
       tr: Transpiler, private fc: FacadeConverter, private enforceUnderscoreConventions: boolean,
       private promoteFunctionLikeMembers: boolean) {
     super(tr);
   }
 
   visitNode(node: ts.Node): boolean {
     switch (node.kind) {
       case ts.SyntaxKind.ModuleDeclaration:
         let moduleDecl = <ts.ModuleDeclaration>node;
+        if (moduleDecl.name.text.slice(0, 2) === '..') {
+          this.emit(
+              '\n// Library augmentation not allowed by Dart. Ignoring augmentation of ' +
+              moduleDecl.name.text + '\n');
+          break;
+        }
         this.emit('\n// Module ' + moduleDecl.name.text + '\n');
-        this.moduleStack.push(moduleDecl.name.text);
-
         this.visit(moduleDecl.body);
         this.emit('\n// End module ' + moduleDecl.name.text + '\n');
-        this.moduleStack.pop();
         break;
       case ts.SyntaxKind.ExportKeyword:
         // TODO(jacobr): perhaps add a specific Dart annotation to indicate
         // exported members or provide a flag to only generate code for exported
         // members.
         break;
       case ts.SyntaxKind.EnumDeclaration: {
         let decl = <ts.EnumDeclaration>node;
         // The only legal modifier for an enum decl is const.
         let isConst = decl.modifiers && (decl.modifiers.flags & ts.NodeFlags.Const);
@@ skipping 34 matching lines @@
 
         if (paramDecl.dotDotDotToken) {
           // Weak support of varargs that works ok if you have 5 of fewer args.
           let paramType: ts.TypeNode;
           let type = paramDecl.type;
           if (type) {
             if (type.kind === ts.SyntaxKind.ArrayType) {
               let arrayType = <ts.ArrayTypeNode>type;
               paramType = arrayType.elementType;
             } else if (type.kind !== ts.SyntaxKind.AnyKeyword) {
-              throw 'Unexpected type for varargs: ' + type.kind;
+              console.log('Warning: falling back to dynamic for varArgs type: ' + type.getText());
             }
           }
 
           for (let i = 1; i <= DeclarationTranspiler.NUM_FAKE_REST_PARAMETERS; ++i) {
             if (i > 1) {
               this.emitNoSpace(',');
             }
             this.visit(paramType);
             this.emit(base.ident(paramDecl.name) + i);
           }
@@ skipping 17 matching lines @@
         if (paramDecl.name.kind !== ts.SyntaxKind.Identifier) {
           throw 'Unsupported parameter name kind: ' + paramDecl.name.kind;
         }
         this.visit(paramDecl.type);
         this.visit(paramDecl.name);
       } break;
       case ts.SyntaxKind.EnumMember: {
         let member = <ts.EnumMember>node;
         this.visit(member.name);
       } break;
+      case ts.SyntaxKind.SourceFile:
+        let sourceFile = node as ts.SourceFile;
+        this.visitMergingOverloads(sourceFile.statements);
+        break;
       case ts.SyntaxKind.ModuleBlock: {
         let block = <ts.ModuleBlock>node;
         this.visitMergingOverloads(block.statements);
       } break;
       case ts.SyntaxKind.VariableDeclarationList: {
         // We have to handle variable declaration lists differently in the case
         // of JS interop because Dart does not support external variables.
         let varDeclList = <ts.VariableDeclarationList>node;
         this.visitList(varDeclList.declarations, ';');
       } break;
@@ skipping 33 matching lines @@
         this.visitParameters(fn.parameters);
         this.emitNoSpace(';');
       } break;
       case ts.SyntaxKind.IndexSignature:
         this.emit('/* Index signature is not yet supported by JavaScript interop. */\n');
         break;
       case ts.SyntaxKind.ExportAssignment:
         // let exportAssignment = <ts.ExportAssignment>node;
         this.emit('/* WARNING: export assignment not yet supported. */\n');
         break;
-      case ts.SyntaxKind.TypeAliasDeclaration:
-        // Dart does not provide special syntax for definning type alais
-        // declarations so we do not emit anything here and resolve alaises
-        // to their original types at each usage site.
-        break;
+      case ts.SyntaxKind.TypeAliasDeclaration: {
+        // Object literal type alias declarations are equivalent to interface declarations.
+        let alias = <ts.TypeAliasDeclaration>node;
+        let type = alias.type;
+        if (type.kind === ts.SyntaxKind.TypeLiteral) {
+          let literal = <ts.TypeLiteralNode>type;
+          this.emit('@anonymous\n@JS()\n');
+          this.visitClassLikeHelper(
+              'abstract class', literal, alias.name, alias.typeParameters, null);
+        } else if (type.kind === ts.SyntaxKind.FunctionType) {
+          // Function type alias definitions are equivalent to dart typedefs.
+          this.visitFunctionTypedefInterface(
+              base.ident(alias.name), type as ts.FunctionTypeNode, alias.typeParameters);
+        } else {
+          this.enterCodeComment();
+          this.emit(alias.getText());
+          this.exitCodeComment();
+          this.emit('\n');
+        }
+        // We ignore other type alias declarations as Dart doesn't have a corresponding feature yet.
+      } break;
       case ts.SyntaxKind.ClassDeclaration:
       case ts.SyntaxKind.InterfaceDeclaration: {
         this.extendsClass = false;
         let classDecl = <ts.ClassDeclaration|ts.InterfaceDeclaration>node;
         let isInterface = node.kind === ts.SyntaxKind.InterfaceDeclaration;
         if (isInterface &&
             base.isFunctionTypedefLikeInterface(classDecl as ts.InterfaceDeclaration)) {
           let member = <ts.CallSignatureDeclaration>classDecl.members[0];
           this.visitFunctionTypedefInterface(classDecl.name.text, member, classDecl.typeParameters);
           break;
         }
 
-        let customName = this.fc.lookupCustomDartTypeName(classDecl.name, this.insideCodeComment);
+        let customName = this.fc.lookupCustomDartTypeName(classDecl.name);
         if (customName && !customName.keep) {
           this.emit('\n/* Skipping class ' + base.ident(classDecl.name) + '*/\n');
           break;
         }
         this.maybeEmitJsAnnotation(node);
 
         if (isInterface ||
             (classDecl.modifiers && (classDecl.modifiers.flags & ts.NodeFlags.Abstract))) {
           this.visitClassLike('abstract class', classDecl);
         } else {
@@ skipping 18 matching lines @@
         let exprWithTypeArgs = <ts.ExpressionWithTypeArguments>node;
         this.visit(exprWithTypeArgs.expression);
         this.maybeVisitTypeArguments(exprWithTypeArgs);
       } break;
       case ts.SyntaxKind.Constructor:
       case ts.SyntaxKind.ConstructSignature: {
         let ctorDecl = <ts.ConstructorDeclaration>node;
         // Find containing class name.
         let classDecl = base.getEnclosingClass(ctorDecl);
         if (!classDecl) this.reportError(ctorDecl, 'cannot find outer class node');
+        let isAnonymous = this.isAnonymousInterface(classDecl);
+        if (isAnonymous) {
+          this.emit('// Constructors on anonymous interfaces are not yet supported.\n');
+          this.enterCodeComment();
+        }
         this.visitDeclarationMetadata(ctorDecl);
         this.fc.visitTypeName(classDecl.name);
         this.visitParameters(ctorDecl.parameters);
         this.emitNoSpace(';');
+        if (isAnonymous) {
+          this.exitCodeComment();
+          this.emit('\n');
+        }
       } break;
       case ts.SyntaxKind.PropertyDeclaration:
         this.visitProperty(<ts.PropertyDeclaration>node);
         break;
       case ts.SyntaxKind.SemicolonClassElement:
         // No-op, don't emit useless declarations.
         break;
       case ts.SyntaxKind.MethodDeclaration:
         this.visitDeclarationMetadata(<ts.MethodDeclaration>node);
         this.visitFunctionLike(<ts.MethodDeclaration>node);
@@ skipping 74 matching lines @@
         }
         this.fc.visitTypeName(<ts.Identifier>name);
       }
 
       if (fn.typeParameters) {
         let insideComment = this.insideCodeComment;
         if (!insideComment) {
           this.enterCodeComment();
         }
         this.emitNoSpace('<');
-        // Emit the names literally instead of visiting, otherwise they will be replaced with the
-        // comment hack themselves.
-        // TODO(jacobr): we can use the regular type parameter visiting pattern
-        // now that we properly track whether we are inside a comment.
-        this.emitNoSpace(fn.typeParameters.map(p => base.ident(p.name)).join(', '));
+        this.enterTypeArguments();
+        this.visitList(fn.typeParameters);
+        this.exitTypeArguments();
         this.emitNoSpace('>');
         if (!insideComment) {
           this.exitCodeComment();
         }
       }
       // Dart does not even allow the parens of an empty param list on getter
       if (accessor !== 'get') {
         this.visitParameters(fn.parameters);
       } else {
         if (fn.parameters && fn.parameters.length > 0) {
@@ skipping 29 matching lines @@
     this.emit('set');
     this.visitName(decl.name);
     this.emitNoSpace('(');
     this.visit(decl.type);
     this.emit('v');
     this.emitNoSpace(')');
     this.emitNoSpace(';');
   }
 
   private visitClassLike(keyword: string, decl: base.ClassLike) {
+    return this.visitClassLikeHelper(
+        keyword, decl, decl.name, decl.typeParameters, decl.heritageClauses);
+  }
+
+  private visitClassLikeHelper(
+      keyword: string, decl: base.ClassLike|ts.TypeLiteralNode, name: ts.Identifier,
+      typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>,
+      heritageClauses: ts.NodeArray<ts.HeritageClause>) {
     this.emit(keyword);
-    this.fc.visitTypeName(decl.name);
-    if (decl.typeParameters) {
+    this.fc.visitTypeName(name);
+    if (typeParameters) {
       this.emit('<');
-      this.visitList(decl.typeParameters);
+      this.enterTypeArguments();
+      this.visitList(typeParameters);
+      this.exitTypeArguments();
       this.emit('>');
     }
 
-    this.visitEachIfPresent(decl.heritageClauses);
+    this.visitEachIfPresent(heritageClauses);
     this.emit('{');
 
     this.maybeEmitFakeConstructors(decl);
 
     // Synthesize explicit properties for ctor with 'property parameters'
     let synthesizePropertyParam = (param: ts.ParameterDeclaration) => {
       if (this.hasFlag(param.modifiers, ts.NodeFlags.Public) ||
           this.hasFlag(param.modifiers, ts.NodeFlags.Private) ||
           this.hasFlag(param.modifiers, ts.NodeFlags.Protected)) {
         // TODO: we should enforce the underscore prefix on privates
         this.visitProperty(param, true);
       }
     };
     (decl.members as ts.NodeArray<ts.Declaration>)
         .filter(base.isConstructor)
         .forEach(
             (ctor) =>
                 (<ts.ConstructorDeclaration>ctor).parameters.forEach(synthesizePropertyParam));
 
-    this.visitClassBody(decl);
+    this.visitClassBody(decl, name);
     this.emit('}');
   }
 
   private visitDeclarationMetadata(decl: ts.Declaration) {
     this.visitEachIfPresent(decl.modifiers);
 
     switch (decl.kind) {
       case ts.SyntaxKind.Constructor:
       case ts.SyntaxKind.ConstructSignature:
         this.emit('external factory');
@@ skipping 14 matching lines @@
       default:
         throw 'Unexpected declaration kind:' + decl.kind;
     }
   }
 
   /**
    * Handles a function typedef-like interface, i.e. an interface that only declares a single
    * call signature, by translating to a Dart `typedef`.
    */
   private visitFunctionTypedefInterface(
-      name: string, signature: ts.CallSignatureDeclaration,
+      name: string, signature: ts.SignatureDeclaration,
       typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>) {
     this.emit('typedef');
     if (signature.type) {
       this.visit(signature.type);
     }
     this.emit(name);
     if (typeParameters) {
       this.emitNoSpace('<');
+      this.enterTypeArguments();
       this.visitList(typeParameters);
+      this.exitTypeArguments();
       this.emitNoSpace('>');
     }
     this.visitParameters(signature.parameters);
     this.emitNoSpace(';');
   }
 }