JS Interop Facade generation polish.

lib/base.ts

 import * as dartStyle from 'dart-style';
+import * as path from 'path';
 import * as ts from 'typescript';
 
 import {OutputContext, Transpiler} from './main';
 
+export type ResolvedTypeMap = {
+  [name: string]: ts.TypeNode
+};
+
+/***
+ * Options for how we display a TypeScript type as a Dart type.
+ */
+export interface TypeDisplayOptions {
+  /**
+   * We are displaying the type inside a comment so we don't have to restrict to valid Dart syntax.
+   * For example, we can display string literal type using the regular TypeScript syntax.
+   */
+  insideComment?: boolean;
+  /**
+   * Dart has additional restrictions for what types are valid to emit inside a type argument. For
+   * example, "void" is not valid inside a type argument so Null has to be used instead.
+   */
+  insideTypeArgument?: boolean;
+  /**
+   * Indicates that we should not append an additional comment indicating what the true TypeScript
+   * type was for cases where Dart cannot express the type precisely.
+   */
+  hideComment?: boolean;
+
+  /**
+   * Parameter declarations to substitute
+   */
+  typeArguments?: ts.TypeNode[];
+
+  resolvedTypeArguments?: ResolvedTypeMap;
+}
+
 export type ClassLike = ts.ClassDeclaration | ts.InterfaceDeclaration;
 export type NamedDeclaration = ClassLike | ts.PropertyDeclaration | ts.VariableDeclaration |
     ts.MethodDeclaration | ts.ModuleDeclaration | ts.FunctionDeclaration;
 
+export interface ExtendedInterfaceDeclaration extends ts.InterfaceDeclaration {
+  /**
+   * VariableDeclaration associated with this interface that we want to treat as the concrete
+   * location of this interface to enable interfaces that act like constructors.
+   * Because Dart does not permit calling objects like constructors we have to add this workaround.
+   */
+  classLikeVariableDeclaration?: ts.VariableDeclaration;
+}
+
 export type Set = {
   [s: string]: boolean
 };
 
 export function ident(n: ts.Node): string {
   if (n.kind === ts.SyntaxKind.Identifier) return (<ts.Identifier>n).text;
+  if (n.kind === ts.SyntaxKind.FirstLiteralToken) {
+    return (n as ts.LiteralLikeNode).text;
+  }
   if (n.kind === ts.SyntaxKind.QualifiedName) {
     let qname = (<ts.QualifiedName>n);
     let leftName = ident(qname.left);
     if (leftName) return leftName + '.' + ident(qname.right);
   }
   return null;
 }
 
 export function isFunctionTypedefLikeInterface(ifDecl: ts.InterfaceDeclaration): boolean {
   return ifDecl.members && ifDecl.members.length === 1 &&
@@ skipping 27 matching lines @@
 
 export function isCallableType(type: ts.TypeNode, tc: ts.TypeChecker): boolean {
   if (isFunctionType(type, tc)) return true;
   if (type.kind === ts.SyntaxKind.TypeReference) {
     if (tc.getSignaturesOfType(tc.getTypeAtLocation(type), ts.SignatureKind.Call).length > 0)
       return true;
   }
   return false;
 }
 
+export function supportedAliasType(alias: ts.TypeAliasDeclaration): boolean {
+  let kind = alias.type.kind;
+  return kind === ts.SyntaxKind.TypeLiteral || kind === ts.SyntaxKind.FunctionType;
+}
+
 export function isFunctionType(type: ts.TypeNode, tc: ts.TypeChecker): boolean {
   let kind = type.kind;
   if (kind === ts.SyntaxKind.FunctionType) return true;
   if (kind === ts.SyntaxKind.TypeReference) {
     let t = tc.getTypeAtLocation(type);
     if (t.symbol && t.symbol.flags & ts.SymbolFlags.Function) return true;
   }
 
+  if (kind === ts.SyntaxKind.IntersectionType) {
+    let types = (<ts.IntersectionTypeNode>type).types;
+    for (let i = 0; i < types.length; ++i) {
+      if (isFunctionType(types[i], tc)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   if (kind === ts.SyntaxKind.UnionType) {
     let types = (<ts.UnionTypeNode>type).types;
     for (let i = 0; i < types.length; ++i) {
       if (!isFunctionType(types[i], tc)) {
         return false;
       }
     }
     return true;
   }
   // Warning: if the kind is a reference type and the reference is to an
   // interface that only has a call member we will not return that it is a
   // function type.
   if (kind === ts.SyntaxKind.TypeLiteral) {
     let members = (<ts.TypeLiteralNode>type).members;
     for (let i = 0; i < members.length; ++i) {
       if (members[i].kind !== ts.SyntaxKind.CallSignature) {
         return false;
       }
     }
     return true;
   }
   return false;
 }
 
+export function isThisParameter(param: ts.ParameterDeclaration): boolean {
+  return param.name && param.name.kind === ts.SyntaxKind.Identifier &&
+      (param.name as ts.Identifier).text === 'this';
+}
+
+/**
+ * Dart does not have a concept of binding the type of the "this" parameter to a method.
+ */
+export function filterThisParameter(params: ts.ParameterDeclaration[]): ts.ParameterDeclaration[] {
+  let ret: ts.ParameterDeclaration[] = [];
+  for (let i = 0; i < params.length; i++) {
+    let param = params[i];
+    if (!isThisParameter(param)) {
+      ret.push(param);
+    }
+  }
+  return ret;
+}
+
 export function isTypeNode(node: ts.Node): boolean {
   switch (node.kind) {
+    case ts.SyntaxKind.IntersectionType:
     case ts.SyntaxKind.UnionType:
+    case ts.SyntaxKind.ParenthesizedType:
     case ts.SyntaxKind.TypeReference:
     case ts.SyntaxKind.TypeLiteral:
     case ts.SyntaxKind.LastTypeNode:
     case ts.SyntaxKind.ArrayType:
     case ts.SyntaxKind.TypePredicate:
     case ts.SyntaxKind.TypeQuery:
     case ts.SyntaxKind.TupleType:
     case ts.SyntaxKind.NumberKeyword:
     case ts.SyntaxKind.StringKeyword:
     case ts.SyntaxKind.VoidKeyword:
+    case ts.SyntaxKind.NullKeyword:
+    case ts.SyntaxKind.UndefinedKeyword:
     case ts.SyntaxKind.BooleanKeyword:
     case ts.SyntaxKind.AnyKeyword:
     case ts.SyntaxKind.FunctionType:
+    case ts.SyntaxKind.ThisType:
       return true;
     default:
       return false;
   }
 }
 
 export function isCallable(decl: ClassLike): boolean {
   let members = decl.members as Array<ts.ClassElement>;
   return members.some((member) => { return member.kind === ts.SyntaxKind.CallSignature; });
 }
@@ skipping 13 matching lines @@
 }
 
 export function getAncestor(n: ts.Node, kind: ts.SyntaxKind): ts.Node {
   for (let parent = n; parent; parent = parent.parent) {
     if (parent.kind === kind) return parent;
   }
   return null;
 }
 
 export function getEnclosingClass(n: ts.Node): ClassLike {
-  for (let parent = n.parent; parent; parent = parent.parent) {
-    if (parent.kind === ts.SyntaxKind.ClassDeclaration ||
-        parent.kind === ts.SyntaxKind.InterfaceDeclaration) {
-      return <ClassLike>parent;
+  while (n) {
+    if (n.kind === ts.SyntaxKind.ClassDeclaration ||
+        n.kind === ts.SyntaxKind.InterfaceDeclaration) {
+      return <ClassLike>n;
     }
+    n = n.parent;
   }
   return null;
 }
 
 export function isConstCall(node: ts.CallExpression): boolean {
   return node && ident(node.expression) === 'CONST_EXPR';
 }
 
 export function isInsideConstExpr(node: ts.Node): boolean {
   return isConstCall(<ts.CallExpression>getAncestor(node, ts.SyntaxKind.CallExpression));
 }
 
-export function formatType(s: string, comment: string, insideCodeComment: boolean): string {
-  if (!comment) {
+export function formatType(s: string, comment: string, options: TypeDisplayOptions): string {
+  if (!comment || options.hideComment) {
     return s;
-  } else if (insideCodeComment) {
+  } else if (options.insideComment) {
     // When inside a comment we only need to emit the comment version which
     // is the syntax we would like to use if Dart supported all language
     // features we would like to use for interop.
     return comment;
   } else {
     let sb = s + '/*';
     // Check if the comment is a valid type name in which case it is safe to use the Dart code
     // written in comments syntax.
     const stubToMakeTypeValidStatement = ' DUMMY_VARIABLE_NAME;';
     comment = comment.trim();
@@ skipping 20 matching lines @@
 
   visit(n: ts.Node) { this.transpiler.visit(n); }
   pushContext(context: OutputContext) { this.transpiler.pushContext(context); }
   popContext() { this.transpiler.popContext(); }
   emit(s: string) { this.transpiler.emit(s); }
   emitNoSpace(s: string) { this.transpiler.emitNoSpace(s); }
   emitType(s: string, comment: string) { this.transpiler.emitType(s, comment); }
   maybeLineBreak() { return this.transpiler.maybeLineBreak(); }
   enterCodeComment() { return this.transpiler.enterCodeComment(); }
   exitCodeComment() { return this.transpiler.exitCodeComment(); }
+
+  enterTypeArguments() { this.transpiler.enterTypeArgument(); }
+  exitTypeArguments() { this.transpiler.exitTypeArgument(); }
+  get insideTypeArgument() { return this.transpiler.insideTypeArgument; }
+
   get insideCodeComment() { return this.transpiler.insideCodeComment; }
 
   emitImport(toEmit: string) {
     if (!this.transpiler.importsEmitted[toEmit]) {
       this.pushContext(OutputContext.Import);
-      this.emit(`import "${toEmit}";`);
+      this.emit(`import "${toEmit}";\n`);
       this.transpiler.importsEmitted[toEmit] = true;
       this.popContext();
     }
   }
 
+  emitImportForSourceFile(sourceFile: ts.SourceFile, context: ts.SourceFile) {
+    if (sourceFile === context) return;
+    if (sourceFile.hasNoDefaultLib) {
+      // We don't want to emit imports to default lib libraries as we replace with Dart equivalents
+      // such as dart:html, etc.
+      return;
+    }
+    let relativePath = path.relative(path.dirname(context.fileName), sourceFile.fileName);
+    this.emitImport(this.transpiler.getDartFileName(relativePath));
+  }
+
+
   reportError(n: ts.Node, message: string) { this.transpiler.reportError(n, message); }
 
   visitNode(n: ts.Node): boolean { throw new Error('not implemented'); }
 
   visitEach(nodes: ts.Node[]) { nodes.forEach((n) => this.visit(n)); }
 
   visitEachIfPresent(nodes?: ts.Node[]) {
     if (nodes) this.visitEach(nodes);
   }
 
   visitList(nodes: ts.Node[], separator = ',') {
     for (let i = 0; i < nodes.length; i++) {
       this.visit(nodes[i]);
       if (i < nodes.length - 1) this.emitNoSpace(separator);
     }
   }
 
+  /**
+   * Returns whether any parameters were actually emitted.
+   * @param nodes
+   * @param separator
+   */
+  visitParameterList(nodes: ts.ParameterDeclaration[]): boolean {
+    let emittedParameters = false;
+    for (let i = 0; i < nodes.length; ++i) {
+      let param = nodes[i];
+      if (!this.insideCodeComment && isThisParameter(param)) {
+        // Emit the this type in a comment as it could be of interest to Dart users who are
+        // calling allowInteropCaptureThis to bind a Dart method.
+        this.enterCodeComment();
+        this.visit(param.type);
+        this.emit('this');
+        this.exitCodeComment();
+        continue;
+      }
+      if (emittedParameters) {
+        this.emitNoSpace(',');
+      }
+      this.visit(param);
+      emittedParameters = true;
+    }
+    return emittedParameters;
+  }
+
   uniqueId(name: string): string {
     const id = this.idCounter++;
     return `_${name}\$\$js_facade_gen\$${id}`;
   }
 
   assert(c: ts.Node, condition: boolean, reason: string): void {
     if (!condition) {
       this.reportError(c, reason);
       throw new Error(reason);
     }
@@ skipping 21 matching lines @@
   }
 
   hasFlag(n: {flags: number}, flag: ts.NodeFlags): boolean {
     return n && (n.flags & flag) !== 0 || false;
   }
 
   getRelativeFileName(fileName: string): string {
     return this.transpiler.getRelativeFileName(fileName);
   }
 
+  getDartFileName(fileName?: string): string { return this.transpiler.getDartFileName(fileName); }
+
   maybeVisitTypeArguments(n: {typeArguments?: ts.NodeArray<ts.TypeNode>}) {
     if (n.typeArguments) {
-      // If it's a single type argument `<void>`, ignore it and emit nothing.
-      // This is particularly useful for `Promise<void>`, see
-      // https://github.com/dart-lang/sdk/issues/2231#issuecomment-108313639
-      if (n.typeArguments.length === 1 && n.typeArguments[0].kind === ts.SyntaxKind.VoidKeyword) {
-        return;
-      }
       this.emitNoSpace('<');
+      this.enterTypeArguments();
       this.visitList(n.typeArguments);
+      this.exitTypeArguments();
       this.emitNoSpace('>');
     }
   }
 
   visitParameters(parameters: ts.ParameterDeclaration[]) {
     this.emitNoSpace('(');
     let firstInitParamIdx = 0;
     for (; firstInitParamIdx < parameters.length; firstInitParamIdx++) {
       // ObjectBindingPatterns are handled within the parameter visit.
       let isOpt = parameters[firstInitParamIdx].initializer ||
           parameters[firstInitParamIdx].questionToken ||
           parameters[firstInitParamIdx].dotDotDotToken;
       if (isOpt && parameters[firstInitParamIdx].name.kind !== ts.SyntaxKind.ObjectBindingPattern) {
         break;
       }
     }
 
+    let hasValidParameters = false;
     if (firstInitParamIdx !== 0) {
       let requiredParams = parameters.slice(0, firstInitParamIdx);
-      this.visitList(requiredParams);
+      hasValidParameters = this.visitParameterList(requiredParams);
     }
 
     if (firstInitParamIdx !== parameters.length) {
-      if (firstInitParamIdx !== 0) this.emitNoSpace(',');
+      if (hasValidParameters) this.emitNoSpace(',');
       let positionalOptional = parameters.slice(firstInitParamIdx, parameters.length);
       this.emit('[');
-      this.visitList(positionalOptional);
+      this.visitParameterList(positionalOptional);
       this.emitNoSpace(']');
     }
 
     this.emitNoSpace(')');
   }
 }