Made properties of top level members with anonymous types static

This also fixed a bug where properties were being emitted twice when declared on both an interface and a variable of the same name

Author: derekxu16

lib/base.ts

@@ -87,6 +87,7 @@ export interface ExtendedInterfaceDeclaration extends ts.InterfaceDeclaration {
 }
 
 export function ident(n: ts.Node): string {
+  if (!n) return null;
   if (ts.isIdentifier(n)) return n.text;
   if (n.kind === ts.SyntaxKind.FirstLiteralToken) return (n as ts.LiteralLikeNode).text;
   if (ts.isQualifiedName(n)) {

lib/merge.ts

@@ -374,9 +374,28 @@ export function normalizeSourceFile(f: ts.SourceFile, fc: FacadeConverter) {
                       if (base.ident(member.name) === 'prototype') {
                         break;
                       }
-                      addModifier(member, ts.createNode(ts.SyntaxKind.StaticKeyword));
-                      member.parent = existing;
-                      Array.prototype.push.call(members, member);
+
+                      // Finds all existing declarations of this property in the inheritance
+                      // hierarchy of this class
+                      const existingDeclarations =
+                          findPropertyInHierarchy(base.ident(member.name), existing, classes);
+
+                      if (existingDeclarations.size) {
+                        // TODO(derekx): For dom.d.ts it makes sense to make all properties that are
+                        // declared on the anonymous types of top level variable declarations
+                        // static, but this may not always be correct
+                        for (const existingDecl of existingDeclarations) {
+                          addModifier(existingDecl, ts.createModifier(ts.SyntaxKind.StaticKeyword));
+                        }
+                      }
+
+                      // If needed, add declaration of property to the interface that we are
+                      // currently handling
+                      if (!findPropertyInClass(base.ident(member.name), existing)) {
+                        addModifier(member, ts.createModifier(ts.SyntaxKind.StaticKeyword));
+                        member.parent = existing;
+                        Array.prototype.push.call(members, member);
+                      }
                       break;
                     case ts.SyntaxKind.IndexSignature:
                       member.parent = existing.parent;
@@ -402,6 +421,37 @@ export function normalizeSourceFile(f: ts.SourceFile, fc: FacadeConverter) {
     }
   }
 
+  function findPropertyInClass(propName: string, classLike: base.ClassLike): ts.ClassElement|
+      undefined {
+    const members = classLike.members as ts.NodeArray<ts.ClassElement>;
+    return members.find((member: ts.ClassElement) => {
+      if (base.ident(member.name) === propName) {
+        return true;
+      }
+    });
+  }
+
+  function findPropertyInHierarchy(
+      propName: string, classLike: base.ClassLike,
+      classes: Map<string, base.ClassLike>): Set<ts.ClassElement> {
+    const propertyDeclarations = new Set<ts.ClassElement>();
+    const declaration = findPropertyInClass(propName, classLike);
+    if (declaration) propertyDeclarations.add(declaration);
+
+    const heritageClauses = classLike.heritageClauses || ts.createNodeArray();
+    for (const clause of heritageClauses) {
+      if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
+        continue;
+      }
+      const name = base.ident(clause.types[0].expression);
+      const declarationsInAncestors = findPropertyInHierarchy(propName, classes.get(name), classes);
+      if (declarationsInAncestors.size) {
+        declarationsInAncestors.forEach(decl => propertyDeclarations.add(decl));
+      }
+    }
+    return propertyDeclarations;
+  }
+
   function removeFromArray(nodes: ts.NodeArray<ts.Node>, v: ts.Node) {
     for (let i = 0, len = nodes.length; i < len; ++i) {
       if (nodes[i] === v) {

test/declaration_test.ts

@@ -519,6 +519,41 @@ abstract class AbstractRange {
   external num get endOffset;
   external num get startOffset;
   external factory AbstractRange();
+}`);
+  });
+
+  it('makes properties of top level variables with anonymous types static', () => {
+    expectTranslate(`
+     declare interface CacheBase {
+      readonly CHECKING: number;
+      readonly DOWNLOADING: number;
+      readonly IDLE: number;
+    }
+    
+    declare interface MyCache extends CacheBase {}
+    
+    declare var MyCache: {
+      prototype: MyCache;
+      new (): MyCache;
+      readonly CHECKING: number;
+      readonly DOWNLOADING: number;
+      readonly IDLE: number;
+    };
+
+     `).to.equal(`@anonymous
+@JS()
+abstract class CacheBase {
+  external static num get CHECKING;
+  external static num get DOWNLOADING;
+  external static num get IDLE;
+}
+
+@JS("MyCache")
+abstract class MyCache implements CacheBase {
+  external factory MyCache();
+  external static num get CHECKING;
+  external static num get DOWNLOADING;
+  external static num get IDLE;
 }`);
   });
 });