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

lib/merge.ts

 import ts = require('typescript');
 import base = require('./base');
 import {FacadeConverter} from './facade_converter';
 
 /**
  * To support arbitrary d.ts files in Dart we often have to merge two TypeScript
  * types into a single Dart type because Dart lacks features such as method
  * overloads, type aliases, and union types.
  */
 export class MergedType {
@@ skipping 33 matching lines @@
               }
 
               this.merge(alias.type);
             }
             return;
           }
           break;
         default:
           break;
       }
-      this.types[this.fc.generateDartTypeName(t, {insideComment: true})] = t;
+      this.types.set(this.fc.generateDartTypeName(t, {insideComment: true}), t);
     }
   }
 
   toTypeNode(): ts.TypeNode {
-    let names = Object.getOwnPropertyNames(this.types);
+    let names = Array.from(this.types.keys());
     if (names.length === 0) {
       return null;
     }
     if (names.length === 1) {
-      return this.types[names[0]];
+      return this.types.get(names[0]);
     }
     let union = <ts.UnionTypeNode>ts.createNode(ts.SyntaxKind.UnionType);
-    base.copyLocation(this.types[names[0]], union);
+    base.copyLocation(this.types.get(names[0]), union);
 
-    union.types = <ts.NodeArray<ts.TypeNode>>[];
-    for (let i = 0; i < names.length; ++i) {
-      union.types.push(this.types[names[i]]);
-    }
+    union.types = Array.from(this.types.values()) as ts.NodeArray<ts.TypeNode>;
     return union;
   }
 
   /**
    * Generate a type node where we have stripped out type features that Dart does not support.
    * Currently this means stripping out union types.
    */
   toSimpleTypeNode(): ts.TypeNode {
     let merged = this.toTypeNode();
     if (merged == null) return null;
 
     if (merged.kind === ts.SyntaxKind.UnionType) {
       // For union types find a Dart type that satisfies all the types.
       let types = (<ts.UnionTypeNode>merged).types;
       // Generate a common base type for an array of types.
       // The implemented is currently incomplete often returning null when there
       // might really be a valid common base type.
       let common: ts.TypeNode = types[0];
       for (let i = 1; i < types.length && common != null; ++i) {
         let type = types[i];
         common = this.fc.findCommonType(type, common);
       }
       return common;
     }
     return merged;
   }
 
-  private types: {[name: string]: ts.TypeNode} = {};
+  private types: Map<string, ts.TypeNode> = new Map();
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
  */
 export class MergedParameter {
   constructor(param: ts.ParameterDeclaration, fc: FacadeConverter) {
     this.type = new MergedType(fc);
     this.textRange = param;
     this.merge(param);
   }
 
   merge(param: ts.ParameterDeclaration) {
-    this.name[base.ident(param.name)] = true;
+    this.name.add(base.ident(param.name));
     if (!this.optional) {
       this.optional = !!param.questionToken;
     }
     this.type.merge(param.type);
   }
 
   toParameterDeclaration(): ts.ParameterDeclaration {
     let ret = <ts.ParameterDeclaration>ts.createNode(ts.SyntaxKind.Parameter);
     let nameIdentifier = <ts.Identifier>ts.createNode(ts.SyntaxKind.Identifier);
-    nameIdentifier.text = Object.getOwnPropertyNames(this.name).join('_');
+    nameIdentifier.text = Array.from(this.name).join('_');
     ret.name = nameIdentifier;
     if (this.optional) {
       ret.questionToken = ts.createNode(ts.SyntaxKind.QuestionToken);
     }
     base.copyLocation(this.textRange, ret);
     ret.type = this.type.toTypeNode();
     return ret;
   }
 
   setOptional() {
     this.optional = true;
   }
 
-  private name: {[s: string]: boolean} = {};
+  private name: Set<string> = new Set();
   private type: MergedType;
   private optional: boolean = false;
   private textRange: ts.TextRange;
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
  */
 export class MergedTypeParameter {
@@ skipping 28 matching lines @@
   private name: string;
   private constraint: MergedType;
   private textRange: ts.TextRange;
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
  */
 export class MergedTypeParameters {
-  private mergedParameters: {[s: string]: MergedTypeParameter} = {};
+  private mergedParameters: Map<string, MergedTypeParameter> = new Map();
   private textRange: ts.TextRange;
 
   constructor(private fc: FacadeConverter) {}
 
   merge(params: ts.NodeArray<ts.TypeParameterDeclaration>) {
     if (!params) return;
     if (!this.textRange) {
       this.textRange = params;
     }
     for (let i = 0; i < params.length; i++) {
       let param = params[i];
       let name = base.ident(param.name);
-      if (Object.hasOwnProperty.call(this.mergedParameters, name)) {
-        let merged = this.mergedParameters[name];
+      if (this.mergedParameters.has(name)) {
+        let merged = this.mergedParameters.get(name);
         if (merged) {
           merged.merge(param);
         }
       } else {
-        this.mergedParameters[name] = new MergedTypeParameter(param, this.fc);
+        this.mergedParameters.set(name, new MergedTypeParameter(param, this.fc));
       }
     }
   }
 
   toTypeParameters(): ts.NodeArray<ts.TypeParameterDeclaration> {
-    let names = Object.getOwnPropertyNames(this.mergedParameters);
-    if (names.length === 0) {
+    if (this.mergedParameters.size === 0) {
       return undefined;
     }
 
     let ret = [] as ts.NodeArray<ts.TypeParameterDeclaration>;
     base.copyLocation(this.textRange, ret);
-    for (let i = 0; i < names.length; ++i) {
-      ret.push(this.mergedParameters[names[i]].toTypeParameterDeclaration());
-    }
+    this.mergedParameters.forEach((mergedParameter) => {
+      ret.push(mergedParameter.toTypeParameterDeclaration());
+    });
+
     return ret;
   }
 }
 
 /**
  * Normalize a SourceFile
  */
 export function normalizeSourceFile(f: ts.SourceFile, fc: FacadeConverter) {
-  let modules: {[name: string]: ts.ModuleDeclaration} = {};
+  let modules: Map<string, ts.ModuleDeclaration> = new Map();
 
   // Merge top level modules.
   for (let i = 0; i < f.statements.length; ++i) {
     let statement = f.statements[i];
     if (statement.kind !== ts.SyntaxKind.ModuleDeclaration) continue;
     let moduleDecl = <ts.ModuleDeclaration>statement;
     let name = moduleDecl.name.text;
-    if (Object.hasOwnProperty.call(modules, name)) {
-      let srcBody = modules[name].body;
+    if (modules.has(name)) {
+      let srcBody = modules.get(name).body;
       let srcBodyBlock: ts.ModuleBlock;
 
       if (srcBody.kind !== ts.SyntaxKind.ModuleBlock) {
         throw 'Module body must be a module block.';
       }
       srcBodyBlock = <ts.ModuleBlock>srcBody;
 
       let body = moduleDecl.body;
       if (body.kind === ts.SyntaxKind.ModuleBlock) {
         let bodyBlock = <ts.ModuleBlock>body;
         Array.prototype.push.apply(srcBodyBlock.statements, bodyBlock.statements);
       } else {
         // moduleDecl.body is a ModuleDeclaration.
         srcBodyBlock.statements.push(moduleDecl.body);
       }
 
       f.statements.splice(i, 1);
       i--;
     } else {
-      modules[name] = moduleDecl;
+      modules.set(name, moduleDecl);
     }
   }
 
   function addModifier(n: ts.Node, modifier: ts.Node) {
     if (!n.modifiers) {
       n.modifiers = <ts.ModifiersArray>[];
       n.modifiers.flags = 0;
     }
     modifier.parent = n;
     n.modifiers.push(modifier);
   }
 
-  function mergeVariablesIntoClasses(n: ts.Node, classes: {[name: string]: base.ClassLike}) {
+  function mergeVariablesIntoClasses(n: ts.Node, classes: Map<string, base.ClassLike>) {
     switch (n.kind) {
       case ts.SyntaxKind.VariableStatement:
         let statement = <ts.VariableStatement>n;
         statement.declarationList.declarations.forEach(function(
             declaration: ts.VariableDeclaration) {
           if (declaration.name.kind === ts.SyntaxKind.Identifier) {
             let name: string = (<ts.Identifier>(declaration.name)).text;
-            let existingClass = Object.hasOwnProperty.call(classes, name);
+            let existingClass = classes.has(name);
             let hasConstructor = false;
             if (declaration.type) {
               let type: ts.TypeNode = declaration.type;
               if (type.kind === ts.SyntaxKind.TypeLiteral) {
                 let literal = <ts.TypeLiteralNode>type;
                 hasConstructor = literal.members.some((member: ts.Node) => {
                   return member.kind === ts.SyntaxKind.ConstructSignature;
                 });
               } else if (type.kind === ts.SyntaxKind.TypeReference) {
                 // Handle interfaces with constructors. As Dart does not support calling arbitrary
@@ skipping 35 matching lines @@
             if (existingClass || hasConstructor) {
               if (!existingClass) {
                 // Create a stub existing class to upgrade the object literal to if there is not an
                 // existing class with the same name.
                 let clazz = <ts.ClassDeclaration>ts.createNode(ts.SyntaxKind.ClassDeclaration);
                 base.copyLocation(declaration, clazz);
                 clazz.name = declaration.name as ts.Identifier;
                 clazz.members = <ts.NodeArray<ts.ClassElement>>[];
                 base.copyLocation(declaration, clazz.members);
                 replaceNode(n, clazz);
-                classes[name] = clazz;
+                classes.set(name, clazz);
               }
 
-              let existing = classes[name];
+              let existing = classes.get(name);
               if (existing.kind === ts.SyntaxKind.InterfaceDeclaration) {
                 let interfaceDecl = existing as base.ExtendedInterfaceDeclaration;
                 // It is completely safe to assume that we know the precise class like variable
                 // declaration for the interface in this case as they have the same exact name.
                 interfaceDecl.classLikeVariableDeclaration = declaration;
               }
               let members = existing.members as Array<ts.ClassElement>;
               if (declaration.type) {
                 let type: ts.TypeNode = declaration.type;
                 if (type.kind === ts.SyntaxKind.TypeLiteral) {
@@ skipping 99 matching lines @@
         break;
       case ts.SyntaxKind.SourceFile:
         let sourceFile = <ts.SourceFile>parent;
         replaceInArray(sourceFile.statements, n, replacement);
         break;
       default:
         throw 'replaceNode not implemented for kind:' + parent.kind;
     }
   }
 
-  function gatherClasses(n: ts.Node, classes: {[name: string]: base.ClassLike}) {
+  function gatherClasses(n: ts.Node, classes: Map<string, base.ClassLike>) {
     switch (n.kind) {
       case ts.SyntaxKind.ClassDeclaration:
       case ts.SyntaxKind.InterfaceDeclaration:
         let classDecl = <base.ClassLike>n;
         let name = classDecl.name.text;
         // TODO(jacobr): validate that the classes have consistent
         // modifiers, etc.
-        if (Object.hasOwnProperty.call(classes, name)) {
-          let existing = classes[name];
+        if (classes.has(name)) {
+          let existing = classes.get(name);
           (classDecl.members as Array<ts.ClassElement>).forEach((e: ts.ClassElement) => {
             (existing.members as Array<ts.ClassElement>).push(e);
             e.parent = existing;
           });
           removeNode(classDecl);
         } else {
-          classes[name] = classDecl;
+          classes.set(name, classDecl);
           // Perform other class level post processing here.
         }
         break;
       case ts.SyntaxKind.ModuleDeclaration:
       case ts.SyntaxKind.SourceFile:
-        let moduleClasses: {[name: string]: base.ClassLike} = {};
+        let moduleClasses: Map<string, base.ClassLike> = new Map();
         ts.forEachChild(n, (child) => gatherClasses(child, moduleClasses));
         ts.forEachChild(n, (child) => mergeVariablesIntoClasses(child, moduleClasses));
 
         break;
       case ts.SyntaxKind.ModuleBlock:
         ts.forEachChild(n, (child) => gatherClasses(child, classes));
         break;
       default:
         break;
     }
   }
-  gatherClasses(f, {});
+  gatherClasses(f, new Map());
 }