Update package name, update and lock clang-format and tslint versions, and format all source files …

lib/facade_converter.ts

 import * as ts from 'typescript';
 
 import * as base from './base';
-import {Set, TypeDisplayOptions} from './base';
+import {TypeDisplayOptions} from './base';
 import {DART_LIBRARIES_FOR_BROWSER_TYPES, TS_TO_DART_TYPENAMES} from './dart_libraries_for_browser_types';
 import {Transpiler} from './main';
 import {MergedType} from './merge';
 
 const FACADE_DEBUG = false;
 const FACADE_NODE_MODULES_PREFIX = /^(\.\.\/)*node_modules\//;
 
 // These constants must be kept in sync with package:func/func.dart which
 // provides a cannonical set of typedefs defining commonly used function types
 // to simplify specifying function types in Dart.
@@ skipping 61 matching lines @@
 
 class DartNameRecord {
   name: string;
   constructor(private node: ts.Node, name: string, private library: DartLibrary) {
     this.name = name;
   }
 }
 
 export class DartLibrary {
   constructor(private fileName: string) {
-    this.usedNames = {};
+    this.usedNames = new Set();
   }
 
   /**
    * @returns {boolean} whether the name was added.
    */
   addName(name: string): boolean {
-    if (Object.prototype.hasOwnProperty.call(this.usedNames, name)) {
+    if (this.usedNames.has(name)) {
       return false;
     }
-    this.usedNames[name] = true;
+    this.usedNames.add(name);
     return true;
   }
 
-  private usedNames: Set;
+  private usedNames: Set<String>;
 }
 
 // TODO(jacobr): track name conflicts better and add library prefixes to avoid them.
 export class NameRewriter {
-  private dartTypes: ts.Map<DartNameRecord> = {};
+  private dartTypes: Map<String, DartNameRecord> = new Map();
   // TODO(jacobr): we aren't really using this well.
-  private libraries: ts.Map<DartLibrary> = {};
+  private libraries: Map<String, DartLibrary> = new Map();
 
   constructor(private fc: FacadeConverter) {}
 
   private computeName(node: base.NamedDeclaration): DartNameRecord {
     let fullPath = fullJsPath(node);
-    if (Object.prototype.hasOwnProperty.call(this.dartTypes, fullPath)) {
-      return this.dartTypes[fullPath];
+    if (this.dartTypes.has(fullPath)) {
+      return this.dartTypes.get(fullPath);
     }
     let sourceFile = <ts.SourceFile>base.getAncestor(node, ts.SyntaxKind.SourceFile);
     let fileName = sourceFile.fileName;
     let library: DartLibrary;
-    if (Object.prototype.hasOwnProperty.call(this.libraries, fileName)) {
-      library = this.libraries[fileName];
+    if (this.libraries.has(fileName)) {
+      library = this.libraries.get(fileName);
     } else {
       library = new DartLibrary(fileName);
-      this.libraries[fileName] = library;
+      this.libraries.set(fileName, library);
     }
     let parts = fullPath.split('.');
     for (let i = parts.length - 1; i >= 0; i--) {
       // Find a unique name by including more of the module hierarchy in the
       // name. This is an arbitrary but hopefully unsurprising scheme to
       // generate unique names. There may be classes or members with conflicting
       // names due to a single d.ts file containing multiple modules.
       let candidateName = fixupIdentifierName(parts.slice(i).join('_'));
       if (library.addName(candidateName)) {
         // Able to add name to library.
         let ret = new DartNameRecord(node, candidateName, library);
-        this.dartTypes[fullPath] = ret;
+        this.dartTypes.set(fullPath, ret);
         return ret;
       }
     }
 
     // Usually the module name prefixes should be sufficient to disambiguate
     // names but sometimes we need to add a numeric prefix as well to
     // disambiguate. We could alternately append the full module prefix as well
     // to make the name choice completely unsurprising albeit even uglier.
     // This case should be very rarely hit.
     let i = 2;
     while (true) {
       let candidateName = parts[parts.length - 1] + i;
       if (library.addName(candidateName)) {
         // Able to add name to library.
         let ret = new DartNameRecord(node, candidateName, library);
-        this.dartTypes[fullPath] = ret;
+        this.dartTypes.set(fullPath, ret);
         return ret;
       }
       i++;
     }
   }
 
   lookupName(node: base.NamedDeclaration, context: ts.Node) {
     let name = this.computeName(node).name;
     return this.fc.resolveImportForSourceFile(node.getSourceFile(), context.getSourceFile(), name);
   }
@@ skipping 36 matching lines @@
     options: TypeDisplayOptions, typeArguments: ts.TypeNode[]): TypeDisplayOptions {
   let ret = cloneOptions(options);
   ret.typeArguments = typeArguments;
   return ret;
 }
 
 function resolveTypeArguments(
     options: TypeDisplayOptions, parameters: ts.TypeParameterDeclaration[]) {
   let ret = cloneOptions(options);
   let typeArguments = options.typeArguments ? options.typeArguments : [];
-  ret.resolvedTypeArguments = {};
+  ret.resolvedTypeArguments = new Map();
   if (parameters) {
     for (let i = 0; i < parameters.length; ++i) {
       let param = parameters[i];
-      ret.resolvedTypeArguments[base.ident(param.name)] = typeArguments[i];
+      ret.resolvedTypeArguments.set(base.ident(param.name), typeArguments[i]);
     }
   }
   // Type arguments have been resolved forward so we don't need to emit them directly.
   ret.typeArguments = null;
   return ret;
 }
 
 function removeResolvedTypeArguments(options: TypeDisplayOptions): TypeDisplayOptions {
   let ret = cloneOptions(options);
   ret.resolvedTypeArguments = null;
   return ret;
 }
 
 export class FacadeConverter extends base.TranspilerBase {
   tc: ts.TypeChecker;
   // For the Dart keyword list see
   // https://www.dartlang.org/docs/dart-up-and-running/ch02.html#keywords
   static DART_RESERVED_WORDS =
       ('assert break case catch class const continue default do else enum extends false final ' +
        'finally for if in is new null rethrow return super switch this throw true try let void ' +
        'while with')
           .split(/ /);
 
   // These are the built-in and limited keywords.
   static DART_OTHER_KEYWORDS =
       ('abstract as async await deferred dynamic export external factory get implements import ' +
        'library operator part set static sync typedef yield call')
           .split(/ /);
 
-  private candidateTypes: {[typeName: string]: boolean} = {};
+  private candidateTypes: Map<string, boolean> = new Map();
   private typingsRootRegex: RegExp;
   private genericMethodDeclDepth = 0;
   private nameRewriter: NameRewriter;
 
-  constructor(transpiler: Transpiler, typingsRoot = '') {
+  constructor(transpiler: Transpiler, typingsRoot?: string) {
     super(transpiler);
+    typingsRoot = typingsRoot || '';
     this.nameRewriter = new NameRewriter(this);
     this.extractPropertyNames(TS_TO_DART_TYPENAMES, this.candidateTypes);
     // Remove this line if decide to support generating code that avoids dart:html.
     Object.keys(DART_LIBRARIES_FOR_BROWSER_TYPES)
-        .forEach((propName) => this.candidateTypes[propName] = true);
+        .forEach((propName) => this.candidateTypes.set(propName, true));
 
     this.typingsRootRegex = new RegExp('^' + typingsRoot.replace('.', '\\.'));
   }
 
-  private extractPropertyNames(m: ts.Map<ts.Map<any>>, candidates: {[k: string]: boolean}) {
+  private extractPropertyNames(m: ts.Map<ts.Map<any>>, candidates: Map<string, boolean>) {
     for (let fileName of Object.keys(m)) {
       const file = m[fileName];
       if (file === undefined) {
         return;
       }
       Object.keys(file)
           .map((propName) => propName.substring(propName.lastIndexOf('.') + 1))
-          .forEach((propName) => candidates[propName] = true);
+          .forEach((propName) => candidates.set(propName, true));
     }
   }
 
   setTypeChecker(tc: ts.TypeChecker) {
     this.tc = tc;
   }
 
   pushTypeParameterNames(n: ts.FunctionLikeDeclaration) {
     if (!n.typeParameters) return;
     this.genericMethodDeclDepth++;
@@ skipping 39 matching lines @@
     if (!t || (t.flags & ts.TypeFlags.TypeParameter) === 0) return false;
 
     // Check if the symbol we're looking at is the type parameter.
     let symbol = this.tc.getSymbolAtLocation(name);
     if (symbol !== t.symbol) return false;
 
     // Check that the Type Parameter has been declared by a function declaration.
     return symbol.declarations.some(d => d.parent.kind === ts.SyntaxKind.FunctionDeclaration);
   }
 
-  generateTypeList(types: ts.TypeNode[], options: TypeDisplayOptions, seperator = ','): string {
+  generateTypeList(types: ts.TypeNode[], options: TypeDisplayOptions, seperator?: string): string {
+    seperator = seperator || ',';
     let that = this;
     return types
         .map((type) => {
           return that.generateDartTypeName(type, addInsideTypeArgument(options));
         })
         .join(seperator);
   }
 
   generateDartTypeName(node: ts.TypeNode, options?: TypeDisplayOptions): string {
     if (!options) {
@@ skipping 280 matching lines @@
       options = {
         insideComment: this.insideCodeComment,
         insideTypeArgument: this.insideTypeArgument
       };
     }
     let ident = base.ident(identifier);
     let symbol: ts.Symbol = this.getSymbolAtLocation(identifier);
     let declaration = this.getSymbolDeclaration(symbol, identifier);
     if (symbol && symbol.flags & ts.SymbolFlags.TypeParameter) {
       let kind = declaration.parent.kind;
-      if (options.resolvedTypeArguments &&
-          Object.hasOwnProperty.call(options.resolvedTypeArguments, ident)) {
+      if (options.resolvedTypeArguments && options.resolvedTypeArguments.has(ident)) {
         return {
           name: this.generateDartTypeName(
-              options.resolvedTypeArguments[ident], removeResolvedTypeArguments(options))
+              options.resolvedTypeArguments.get(ident), removeResolvedTypeArguments(options))
         };
       }
       // Only kinds of TypeParameters supported by Dart.
       if (kind !== ts.SyntaxKind.ClassDeclaration && kind !== ts.SyntaxKind.InterfaceDeclaration &&
           kind !== ts.SyntaxKind.TypeAliasDeclaration) {
         return {name: 'dynamic', comment: ident};
       }
     }
 
-    if (this.candidateTypes.hasOwnProperty(ident)) {
+    if (this.candidateTypes.has(ident)) {
       if (!symbol) {
         return null;
       }
 
       let fileAndName = this.getFileAndName(identifier, symbol);
 
       if (fileAndName) {
         let fileSubs = TS_TO_DART_TYPENAMES[fileAndName.fileName];
         if (fileSubs) {
           let name = fileAndName.qname;
@@ skipping 219 matching lines @@
     let qname = this.tc.getFullyQualifiedName(symbol);
     // Some Qualified Names include their file name. Might be a bug in TypeScript,
     // for the time being just special case.
     if (symbol.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Function | ts.SymbolFlags.Variable)) {
       qname = symbol.getName();
     }
     if (FACADE_DEBUG) console.error('fn:', fileName, 'cfn:', canonicalFileName, 'qn:', qname);
     return {fileName: canonicalFileName, qname};
   }
 }