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

lib/base.ts

 import * as dartStyle from 'dart-style';
 import * as path from 'path';
 import * as ts from 'typescript';
 
 import {OutputContext, Transpiler} from './main';
 
 /**
  * Map from identifier name to resolved type.
  * Example: 'E' should map to a TypeNode for number when resolving a usage of MyArray<number>
  * where MyArray is the alias type:
  * type MyArray<E> = Array<T>
  */
-export type ResolvedTypeMap = {
-  [name: string]: ts.TypeNode
-};
+export type ResolvedTypeMap = Map<string, ts.TypeNode>;
 
 /***
  * Options for how TypeScript types are represented as Dart types.
  */
 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.
   ///
   /// Example:
   /// TypeScript type: number|string
@@ skipping 34 matching lines @@
    * arguments that are not representable in Dart.
    */
   resolvedTypeArguments?: ResolvedTypeMap;
 }
 
 /**
  * Summary information on what is imported via a particular import.
  */
 export class ImportSummary {
   showAll: boolean = false;
-  shown: Set = {};
+  shown: Set<String> = new Set();
   asPrefix: string;
 }
 
 export type ClassLike = ts.ClassDeclaration | ts.InterfaceDeclaration;
 export type NamedDeclaration = ClassLike | ts.PropertyDeclaration | ts.VariableDeclaration |
     ts.MethodDeclaration | ts.ModuleDeclaration | ts.FunctionDeclaration;
 
-export type Set = {
-  [s: string]: boolean
-};
-
 /**
  * Interface extending the true InterfaceDeclaration interface to add optional state we store on
  * interfaces to simplify conversion to Dart classes.
  */
 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.
    */
@@ skipping 274 matching lines @@
   }
   get insideTypeArgument() {
     return this.transpiler.insideTypeArgument;
   }
 
   get insideCodeComment() {
     return this.transpiler.insideCodeComment;
   }
 
   getImportSummary(libraryUri: string): ImportSummary {
-    if (!Object.hasOwnProperty.call(this.transpiler.imports, libraryUri)) {
+    if (!this.transpiler.imports.has(libraryUri)) {
       let summary = new ImportSummary();
-      this.transpiler.imports[libraryUri] = summary;
+      this.transpiler.imports.set(libraryUri, summary);
       return summary;
     }
-    return this.transpiler.imports[libraryUri];
+    return this.transpiler.imports.get(libraryUri);
   }
 
   /**
    * Add an import. If an identifier is specified, only show that name.
    */
   addImport(libraryUri: string, identifier?: string): ImportSummary {
     let summary = this.getImportSummary(libraryUri);
     if (identifier) {
-      summary.shown[identifier] = true;
+      summary.shown.add(identifier);
     } else {
       summary.showAll = true;
     }
     return summary;
   }
 
   /**
    * Return resolved named possibly including a prefix for the identifier.
    */
   resolveImportForSourceFile(sourceFile: ts.SourceFile, context: ts.SourceFile, identifier: string):
@@ skipping 26 matching lines @@
   }
 
   visitEach(nodes: ts.Node[]) {
     nodes.forEach((n) => this.visit(n));
   }
 
   visitEachIfPresent(nodes?: ts.Node[]) {
     if (nodes) this.visitEach(nodes);
   }
 
-  visitList(nodes: ts.Node[], separator = ',') {
+  visitList(nodes: ts.Node[], separator?: string) {
+    separator = 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.
    */
   visitParameterList(nodes: ts.ParameterDeclaration[]): boolean {
@@ skipping 98 matching lines @@
       if (hasValidParameters) this.emitNoSpace(',');
       let positionalOptional = parameters.slice(firstInitParamIdx, parameters.length);
       this.emit('[');
       this.visitParameterList(positionalOptional);
       this.emitNoSpace(']');
     }
 
     this.emitNoSpace(')');
   }
 }