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 {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\//;
@@ skipping 64 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 = {}; }
+  constructor(private fileName: string) {
+    this.usedNames = {};
+  }
 
   /**
    * @returns {boolean} whether the name was added.
    */
   addName(name: string): boolean {
     if (Object.prototype.hasOwnProperty.call(this.usedNames, name)) {
       return false;
     }
     this.usedNames[name] = true;
     return true;
@@ skipping 162 matching lines @@
       const file = m[fileName];
       if (file === undefined) {
         return;
       }
       Object.keys(file)
           .map((propName) => propName.substring(propName.lastIndexOf('.') + 1))
           .forEach((propName) => candidates[propName] = true);
     }
   }
 
-  setTypeChecker(tc: ts.TypeChecker) { this.tc = tc; }
+  setTypeChecker(tc: ts.TypeChecker) {
+    this.tc = tc;
+  }
 
   pushTypeParameterNames(n: ts.FunctionLikeDeclaration) {
     if (!n.typeParameters) return;
     this.genericMethodDeclDepth++;
   }
 
   popTypeParameterNames(n: ts.FunctionLikeDeclaration) {
     if (!n.typeParameters) return;
     this.genericMethodDeclDepth--;
   }
@@ skipping 36 matching lines @@
     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 {
     let that = this;
     return types
-        .map((type) => { return that.generateDartTypeName(type, addInsideTypeArgument(options)); })
+        .map((type) => {
+          return that.generateDartTypeName(type, addInsideTypeArgument(options));
+        })
         .join(seperator);
   }
 
   generateDartTypeName(node: ts.TypeNode, options?: TypeDisplayOptions): string {
     if (!options) {
       options = {
         insideComment: this.insideCodeComment,
         insideTypeArgument: this.insideTypeArgument
       };
     }
@@ skipping 371 matching lines @@
   /**
    * This method works around the lack of Dart support for union types
    * generating a valid Dart type that satisfies all the types passed in.
    */
   toSimpleDartType(types: Array<ts.TypeNode>): ts.TypeNode {
     // We use MergeType to ensure that we have already deduped types that are
     // equivalent even if they aren't obviously identical.
     // MergedType will also follow typed aliases, etc which allows us to avoid
     // including that logic here as well.
     let mergedType = new MergedType(this);
-    types.forEach((type) => { mergedType.merge(type); });
+    types.forEach((type) => {
+      mergedType.merge(type);
+    });
     return mergedType.toSimpleTypeNode();
   }
 
   findCommonType(type: ts.TypeNode, common: ts.TypeNode): ts.TypeNode {
     if (common === type) return common;
 
     // If both types generate the exact same Dart type name without comments then
     // there is no need to do anything. The types
     if (this.generateDartTypeName(common, {hideComment: true}) ===
         this.generateDartTypeName(type, {hideComment: true})) {
@@ skipping 135 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};
   }
 }