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

lib/facade_converter.ts

 import * as ts from 'typescript';
 
 import * as base from './base';
 import {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 337 matching lines @@
       return 'dynamic';
     }
 
     switch (node.kind) {
       case ts.SyntaxKind.TypeQuery:
         name = 'dynamic';
         // TODO(jacobr): evaluate supporting this case.
         // let query = <ts.TypeQueryNode>node;
         // name += '/* TypeQuery: typeof ' + base.ident(query.exprName) + ' */';
         break;
-      case ts.SyntaxKind.TypePredicate:
-        return this.generateDartTypeName((node as ts.TypePredicateNode).type, options);
+      case ts.SyntaxKind.TypePredicate: {
+        let predicate = node as ts.TypePredicateNode;
+        name = 'bool';
+        comment = base.ident(predicate.parameterName) + ' is ' +
+            this.generateDartTypeName(predicate.type, addInsideComment(options));
+      } break;
       case ts.SyntaxKind.TupleType:
         let tuple = <ts.TupleTypeNode>node;
         name = 'List<';
         let mergedType = new MergedType(this);
         tuple.elementTypes.forEach((t) => mergedType.merge(t));
         name += this.generateDartTypeName(mergedType.toTypeNode(), addInsideTypeArgument(options));
         name += '>';
         // This is intentionally not valid Dart code so that it is clear this isn't a Dart
         // code comment that should use the /*= syntax.
         comment = 'Tuple of <' +
@@ skipping 401 matching lines @@
 
   toTypeNode(type: ts.Type): ts.TypeNode {
     if (!type) return null;
     let symbol = type.getSymbol();
     if (!symbol) return null;
 
     let referenceType = <ts.TypeReferenceNode>ts.createNode(ts.SyntaxKind.TypeReference);
     // TODO(jacobr): property need to prefix the name better.
     referenceType.typeName = this.createEntityName(symbol);
     referenceType.typeName.parent = referenceType;
+    let decl = this.getSymbolDeclaration(symbol);
+    base.copyLocation(decl, referenceType);
     return referenceType;
   }
 
   createEntityName(symbol: ts.Symbol): ts.EntityName {
     let parts = this.tc.getFullyQualifiedName(symbol).split('.');
     let identifier = <ts.Identifier>ts.createNode(ts.SyntaxKind.Identifier);
     identifier.text = parts[parts.length - 1];
     // TODO(jacobr): do we need to include all parts in the entity name?
     return identifier;
   }
@@ skipping 25 matching lines @@
 
   commonSupertype(nodeA: ts.TypeNode, nodeB: ts.TypeNode): ts.TypeNode {
     if (nodeA == null || nodeB == null) return null;
     if (nodeA.kind === ts.SyntaxKind.TypeReference && nodeB.kind === ts.SyntaxKind.TypeReference) {
       // Handle the trivial case where the types are identical except for type arguments.
       // We could do a better job and actually attempt to merge type arguments.
       let refA = nodeA as ts.TypeReferenceNode;
       let refB = nodeB as ts.TypeReferenceNode;
       if (base.ident(refA.typeName) === base.ident(refB.typeName)) {
         let merge = <ts.TypeReferenceNode>ts.createNode(ts.SyntaxKind.TypeReference);
+        base.copyLocation(refA, merge);
         merge.typeName = refA.typeName;
         return merge;
       }
     }
     return this.toTypeNode(this.getCommonSupertype(
         this.tc.getTypeAtLocation(nodeA), this.tc.getTypeAtLocation(nodeB)));
   }
 
   getCommonSupertype(a: ts.Type, b: ts.Type): ts.Type {
     if (a === b) return a;
@@ skipping 36 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};
   }
 }