Fix crash generating facades for loasd. Fix bug in how we handle TypePredicates. Add test for TypeP…

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 118 matching lines @@
     return ret;
   }
 
   setOptional() {
     this.optional = true;
   }
 
   private name: Set<string> = new Set();
   private type: MergedType;
   private optional: boolean = false;
-  private textRange: ts.TextRange;
+  private textRange: ts.Node;
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
  */
 export class MergedTypeParameter {
   constructor(param: ts.TypeParameterDeclaration, fc: FacadeConverter) {
     this.constraint = new MergedType(fc);
     this.textRange = param;
@@ skipping 17 matching lines @@
     // We can't currently handle union types in merged type parameters as the comments for type
     // parameters in function types are not there for documentation and impact strong mode.
     if (constraint && constraint.kind !== ts.SyntaxKind.UnionType) {
       ret.constraint = constraint;
     }
     return ret;
   }
 
   private name: string;
   private constraint: MergedType;
-  private textRange: ts.TextRange;
+  private textRange: ts.Node;
 }
 
 /**
  * Handle a parameter that is the result of merging parameter declarations from
  * multiple method overloads.
  */
 export class MergedTypeParameters {
   private mergedParameters: Map<string, MergedTypeParameter> = new Map();
   private textRange: ts.TextRange;
 
@@ skipping 17 matching lines @@
       }
     }
   }
 
   toTypeParameters(): ts.NodeArray<ts.TypeParameterDeclaration> {
     if (this.mergedParameters.size === 0) {
       return undefined;
     }
 
     let ret = [] as ts.NodeArray<ts.TypeParameterDeclaration>;
-    base.copyLocation(this.textRange, ret);
+    base.copyNodeArrayLocation(this.textRange, ret);
+
     this.mergedParameters.forEach((mergedParameter) => {
       ret.push(mergedParameter.toTypeParameterDeclaration());
     });
 
     return ret;
   }
 }
 
 /**
  * Normalize a SourceFile
@@ skipping 96 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);
+                base.copyNodeArrayLocation(declaration, clazz.members);
                 replaceNode(n, clazz);
                 classes.set(name, clazz);
               }
 
               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;
@@ skipping 140 matching lines @@
         break;
       case ts.SyntaxKind.ModuleBlock:
         ts.forEachChild(n, (child) => gatherClasses(child, classes));
         break;
       default:
         break;
     }
   }
   gatherClasses(f, new Map());
 }