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:
@@ skipping 232 matching lines @@
     case ts.SyntaxKind.FunctionType:
     case ts.SyntaxKind.ThisType:
       return true;
     default:
       return false;
   }
 }
 
 export function isCallable(decl: ClassLike): boolean {
   let members = decl.members as Array<ts.ClassElement>;
-  return members.some((member) => { return member.kind === ts.SyntaxKind.CallSignature; });
+  return members.some((member) => {
+    return member.kind === ts.SyntaxKind.CallSignature;
+  });
 }
 
 export function copyLocation(src: ts.TextRange, dest: ts.TextRange) {
   dest.pos = src.pos;
   dest.end = src.end;
 }
 
 // Polyfill for ES6 Array.find.
 export function arrayFindPolyfill<T>(
     nodeArray: ts.NodeArray<T>, predicate: (node: T) => boolean): T {
@@ skipping 57 matching lines @@
     sb += comment;
     sb += '*/';
     return sb;
   }
 }
 
 export class TranspilerBase {
   private idCounter: number = 0;
   constructor(protected transpiler: Transpiler) {}
 
-  visit(n: ts.Node) { this.transpiler.visit(n); }
-  pushContext(context: OutputContext) { this.transpiler.pushContext(context); }
-  popContext() { this.transpiler.popContext(); }
-  emit(s: string) { this.transpiler.emit(s); }
-  emitNoSpace(s: string) { this.transpiler.emitNoSpace(s); }
-  emitType(s: string, comment: string) { this.transpiler.emitType(s, comment); }
-  maybeLineBreak() { return this.transpiler.maybeLineBreak(); }
-  enterCodeComment() { return this.transpiler.enterCodeComment(); }
-  exitCodeComment() { return this.transpiler.exitCodeComment(); }
+  visit(n: ts.Node) {
+    this.transpiler.visit(n);
+  }
+  pushContext(context: OutputContext) {
+    this.transpiler.pushContext(context);
+  }
+  popContext() {
+    this.transpiler.popContext();
+  }
+  emit(s: string) {
+    this.transpiler.emit(s);
+  }
+  emitNoSpace(s: string) {
+    this.transpiler.emitNoSpace(s);
+  }
+  emitType(s: string, comment: string) {
+    this.transpiler.emitType(s, comment);
+  }
+  maybeLineBreak() {
+    return this.transpiler.maybeLineBreak();
+  }
+  enterCodeComment() {
+    return this.transpiler.enterCodeComment();
+  }
+  exitCodeComment() {
+    return this.transpiler.exitCodeComment();
+  }
 
-  enterTypeArguments() { this.transpiler.enterTypeArgument(); }
-  exitTypeArguments() { this.transpiler.exitTypeArgument(); }
-  get insideTypeArgument() { return this.transpiler.insideTypeArgument; }
+  enterTypeArguments() {
+    this.transpiler.enterTypeArgument();
+  }
+  exitTypeArguments() {
+    this.transpiler.exitTypeArgument();
+  }
+  get insideTypeArgument() {
+    return this.transpiler.insideTypeArgument;
+  }
 
-  get insideCodeComment() { return this.transpiler.insideCodeComment; }
+  get insideCodeComment() {
+    return this.transpiler.insideCodeComment;
+  }
 
   getImportSummary(libraryUri: string): ImportSummary {
     if (!Object.hasOwnProperty.call(this.transpiler.imports, libraryUri)) {
       let summary = new ImportSummary();
       this.transpiler.imports[libraryUri] = summary;
       return summary;
     }
     return this.transpiler.imports[libraryUri];
   }
 
@@ skipping 27 matching lines @@
     let parts = this.getDartFileName(relativePath).split('/');
     let fileName = parts[parts.length - 1];
     let identifierParts = identifier.split('.');
     identifier = identifierParts[identifierParts.length - 1];
     let summary = this.addImport(this.transpiler.getDartFileName(fileName), identifier);
     if (summary.asPrefix) return summary.asPrefix + '.' + identifier;
     return identifier;
   }
 
 
-  reportError(n: ts.Node, message: string) { this.transpiler.reportError(n, message); }
+  reportError(n: ts.Node, message: string) {
+    this.transpiler.reportError(n, message);
+  }
 
-  visitNode(n: ts.Node): boolean { throw new Error('not implemented'); }
+  visitNode(n: ts.Node): boolean {
+    throw new Error('not implemented');
+  }
 
-  visitEach(nodes: ts.Node[]) { nodes.forEach((n) => this.visit(n)); }
+  visitEach(nodes: ts.Node[]) {
+    nodes.forEach((n) => this.visit(n));
+  }
 
   visitEachIfPresent(nodes?: ts.Node[]) {
     if (nodes) this.visitEach(nodes);
   }
 
   visitList(nodes: ts.Node[], separator = ',') {
     for (let i = 0; i < nodes.length; i++) {
       this.visit(nodes[i]);
       if (i < nodes.length - 1) this.emitNoSpace(separator);
     }
@@ skipping 36 matching lines @@
     }
   }
 
   getAncestor(n: ts.Node, kind: ts.SyntaxKind): ts.Node {
     for (let parent = n; parent; parent = parent.parent) {
       if (parent.kind === kind) return parent;
     }
     return null;
   }
 
-  hasAncestor(n: ts.Node, kind: ts.SyntaxKind): boolean { return !!getAncestor(n, kind); }
+  hasAncestor(n: ts.Node, kind: ts.SyntaxKind): boolean {
+    return !!getAncestor(n, kind);
+  }
 
   hasAnnotation(decorators: ts.NodeArray<ts.Decorator>, name: string): boolean {
     if (!decorators) return false;
     return decorators.some((d) => {
       let decName = ident(d.expression);
       if (decName === name) return true;
       if (d.expression.kind !== ts.SyntaxKind.CallExpression) return false;
       let callExpr = (<ts.CallExpression>d.expression);
       decName = ident(callExpr.expression);
       return decName === name;
     });
   }
 
   hasFlag(n: {flags: number}, flag: ts.NodeFlags): boolean {
     return n && (n.flags & flag) !== 0 || false;
   }
 
   getRelativeFileName(fileName: string): string {
     return this.transpiler.getRelativeFileName(fileName);
   }
 
-  getDartFileName(fileName?: string): string { return this.transpiler.getDartFileName(fileName); }
+  getDartFileName(fileName?: string): string {
+    return this.transpiler.getDartFileName(fileName);
+  }
 
   maybeVisitTypeArguments(n: {typeArguments?: ts.NodeArray<ts.TypeNode>}) {
     if (n.typeArguments) {
       this.emitNoSpace('<');
       this.enterTypeArguments();
       this.visitList(n.typeArguments);
       this.exitTypeArguments();
       this.emitNoSpace('>');
     }
   }
@@ skipping 21 matching lines @@
       if (hasValidParameters) this.emitNoSpace(',');
       let positionalOptional = parameters.slice(firstInitParamIdx, parameters.length);
       this.emit('[');
       this.visitParameterList(positionalOptional);
       this.emitNoSpace(']');
     }
 
     this.emitNoSpace(')');
   }
 }