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

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, MergedTypeParameters} from './merge';
 
 export function isFunctionLikeProperty(
     decl: ts.PropertyDeclaration|ts.ParameterDeclaration, tc: ts.TypeChecker): boolean {
   if (!decl.type) return false;
@@ skipping 11 matching lines @@
 
   static NUM_FAKE_REST_PARAMETERS = 5;
 
   setTypeChecker(tc: ts.TypeChecker) {
     this.tc = tc;
   }
   setFacadeConverter(fc: FacadeConverter) {
     this.fc = fc;
   }
 
-  getJsPath(node: ts.Node, suppressUnneededPaths = true): string {
+  getJsPath(node: ts.Node, suppressUnneededPaths: boolean): 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;
     }
 
@@ skipping 58 matching lines @@
   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);
+    let name: String = this.getJsPath(node, true);
     this.emit('@JS(');
     if (name.length > 0) {
       this.emit('"' + name + '"');
     }
     this.emit(')');
   }
 
   /**
    * Emit fake constructors to placate the Dart Analyzer for JS Interop classes.
    */
@@ skipping 120 matching lines @@
         let p = properties[i];
         this.visit(p.type);
         this.visit(p.name);
       }
       this.emitNoSpace('});');
     }
   }
 
   visitMergingOverloads(members: Array<ts.Node>) {
     // TODO(jacobr): merge method overloads.
-    let groups: {[name: string]: Array<ts.Node>} = {};
+    let groups: Map<string, Array<ts.Node>> = new Map();
     let orderedGroups: Array<Array<ts.Node>> = [];
     members.forEach((node) => {
       let name = '';
       switch (node.kind) {
         case ts.SyntaxKind.Block:
           // For JS interop we always skip the contents of a block.
           break;
         case ts.SyntaxKind.PropertyDeclaration:
         case ts.SyntaxKind.PropertySignature:
         case ts.SyntaxKind.VariableDeclaration: {
@@ skipping 39 matching lines @@
           break;
         case ts.SyntaxKind.IndexSignature:
           name = '[]';
           break;
         default:
           // Create a group with a single entry as merging is not required for this node kind.
           orderedGroups.push([node]);
           return;
       }
       let group: Array<ts.Node>;
-      if (Object.prototype.hasOwnProperty.call(groups, name)) {
-        group = groups[name];
+      if (groups.has(name)) {
+        group = groups.get(name);
       } else {
         group = [];
-        groups[name] = group;
+        groups.set(name, group);
         orderedGroups.push(group);
       }
       group.push(node);
     });
 
     orderedGroups.forEach((group: Array<ts.Node>) => {
       if (group.length === 1) {
         this.visit(group[0]);
         return;
       }
@@ skipping 443 matching lines @@
 
   /**
    * Visit a property declaration.
    * In the special case of property parameters in a constructor, we also allow
    * a parameter to be emitted as a property.
    * We have to emit properties as getter setter pairs as Dart does not support
    * external fields.
    * In the special case of property parameters in a constructor, we also allow a parameter to be
    * emitted as a property.
    */
-  private visitProperty(decl: ts.PropertyDeclaration|ts.ParameterDeclaration, isParameter = false) {
+  private visitProperty(
+      decl: ts.PropertyDeclaration|ts.ParameterDeclaration, isParameter?: boolean) {
     let isStatic = base.isStatic(decl);
     this.emit('external');
     if (isStatic) this.emit('static');
     this.visit(decl.type);
     this.emit('get');
     this.visitName(decl.name);
     this.emitNoSpace(';');
 
     this.emit('external');
     if (isStatic) this.emit('static');
@@ skipping 97 matching lines @@
       this.emitNoSpace('<');
       this.enterTypeArguments();
       this.visitList(typeParameters);
       this.exitTypeArguments();
       this.emitNoSpace('>');
     }
     this.visitParameters(signature.parameters);
     this.emitNoSpace(';');
   }
 }