fix dedups fields from prototype chain.

Closure @Lends is a way to extend a type with the fields of an object
literal.

This allows to introduce a field on a prototype object that is already
defined in the constructor. In TS the fields are generated in the same
class block, so deduping is needed.

Author: rkirov

src/main/java/com/google/javascript/cl2dts/DeclarationGenerator.java

@@ -831,8 +831,8 @@ private void visitObjectType(ObjectType type, ObjectType prototype, Boolean proc
         emit("[key: string]: any;");
         emitBreak();
       }
-      // Methods.
-      visitProperties(prototype, false);
+      // Prototype fields (mostly methods).
+      visitProperties(prototype, false, ((ObjectType) instanceType).getOwnPropertyNames());
       // Statics.
       if (processStatics) {
         visitProperties(type, true);
@@ -843,7 +843,13 @@ private void visitObjectType(ObjectType type, ObjectType prototype, Boolean proc
     }
 
     private void visitProperties(ObjectType objType, boolean isStatic) {
+      visitProperties(objType, isStatic,  Collections.<String>emptySet());
+    }
+
+    private void visitProperties(ObjectType objType, boolean isStatic, Set<String> skipNames) {
       for (String propName : objType.getOwnPropertyNames()) {
+        if (skipNames.contains(propName)) continue;
+
         if ("prototype".equals(propName) || "superClass_".equals(propName)
             // constructors are handled in #visitObjectType
             || "constructor".equals(propName)) {

src/test/java/com/google/javascript/cl2dts/lends.d.ts

@@ -0,0 +1,17 @@
+declare namespace ಠ_ಠ.cl2dts_internal.lends {
+  class A {
+    a : string ;
+    c : boolean ;
+    static b : number ;
+  }
+}
+declare module 'goog:lends.A' {
+  import alias = ಠ_ಠ.cl2dts_internal.lends.A;
+  export default alias;
+}
+declare namespace ಠ_ಠ.cl2dts_internal.lends {
+}
+declare module 'goog:lends' {
+  import alias = ಠ_ಠ.cl2dts_internal.lends;
+  export = alias;
+}

src/test/java/com/google/javascript/cl2dts/lends.js

@@ -0,0 +1,19 @@
+goog.provide('lends');
+goog.provide('lends.A');
+
+/**
+ * @constructor
+ */
+lends.A = function() {
+  /** @type {string} */
+  this.a = "";
+};
+
+goog.object.extend(lends.A, /** @lends {lends.A} */ {b: 1});
+
+// lends manages to avoid the deduping of fields, and as far as closure
+// is concerned there is a field a on the prototype and on the instance.
+// Also the presense of @lends extends the type signature of A.prototype.
+goog.object.extend(lends.A.prototype, /** @lends {lends.A.prototype} */ {a: 1, c: true});
+
+

src/test/java/com/google/javascript/cl2dts/lends_usage.ts

@@ -0,0 +1,3 @@
+import A from "goog:lends.A";
+
+var a: A = new A();

src/test/java/com/google/javascript/cl2dts/provide_single_class.d.ts

@@ -12,6 +12,7 @@ declare module 'goog:foo.bar.Baz.NestedEnum' {
 declare namespace ಠ_ಠ.cl2dts_internal.foo.bar {
   class Baz {
     field : string ;
+    avalue : number ;
     equals (b : Baz.NestedClass ) : boolean ;
     method (a : string ) : number ;
     static staticMethod (a : string ) : number ;

src/test/java/com/google/javascript/cl2dts/provide_single_class.js

@@ -6,6 +6,12 @@ goog.provide('foo.bar.Baz.NestedEnum');
 foo.bar.Baz = function() {
   /** @type {string} */
   this.field = 'a';
+  // Surprisingly, defining the same field on the prototype and in
+  // the constructor with different signatures doesn't throw a type error.
+  // The type of the prototype is preferred and as far as types are
+  // concerned `avalue` lives on the prototype object.
+  /** @type {string} */
+  this.avalue = 0;
 };
 
 /**
@@ -16,6 +22,11 @@ foo.bar.Baz.staticMethod = function(a) {
   return Number(a)
 };
 
+/**
+ * @type {number}
+ */
+foo.bar.Baz.prototype.avalue = 0;
+
 /**
  * @param {string} a
  * @return {number}