Added --trust-js-types flag

Added the --trust-js-types flag to emit @anonymous tags on classes that have neither constructors nor static methods

* Started emitting @anonymous tags on classes that have neither constructors nor static methods

* Added the --trust-js-types flag to control this behavior

* Updated the --trust-js-types flag description in the README

Author: derekxu16

README.md

@@ -22,6 +22,7 @@ Dart interop facade file is written to stdout.
 `--base-path=<input d.ts file directory>`: specify the directory that contains the input d.ts files<br/>
 `--generate-html`: generate facades for dart:html types rather than importing them<br/>
 `--explicit-static`: disables default assumption that properties declared on the anonymous types of top level variable declarations are static
+`--trust-js-types`: Emits @anonymous tags on classes that have neither constructors nor static members. This prevents the Dart Dev Compiler from checking whether or not objects are truly instances of those classes. This flag should be used if the input JS/TS library has structural types, or is otherwise claiming that types match in cases where the correct JS prototype is not there for DDC to check against.
 
 ### Example
 `dart_js_facade_gen --destination=/usr/foo/tmp/chartjs/lib --base-path=/usr/foo/git/DefinitelyTyped/chartjs /usr/foo/git/DefinitelyTyped/chartjs/chart.d.ts`

index.js

@@ -4,12 +4,13 @@ const main = require('./build/lib/main.js');
 
 var args = require('minimist')(process.argv.slice(2), {
   base: 'string',
-  boolean: ['semantic-diagnostics', 'generate-html', 'explicit-static'],
+  boolean: ['semantic-diagnostics', 'generate-html', 'explicit-static', 'trust-js-types'],
   alias: {
     'base-path': 'basePath',
     'semantic-diagnostics': 'semanticDiagnostics',
     'generate-html': 'generateHTML',
-    'explicit-static': 'explicitStatic'
+    'explicit-static': 'explicitStatic',
+    'trust-js-types': 'trustJSTypes'
   }
 });
 try {

lib/declaration.ts

@@ -99,20 +99,30 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
     return path.join('.');
   }
 
-  private isAnonymousInterface(node: ts.Node): boolean {
-    if (!ts.isInterfaceDeclaration(node)) return false;
-    let interfaceDecl = node as base.ExtendedInterfaceDeclaration;
-    // If we were able to associate a variable declaration with the interface definition then
-    // the interface isn't actually anonymous.
-    return !interfaceDecl.classLikeVariableDeclaration;
+  private isAnonymous(node: ts.Node): boolean {
+    if (ts.isInterfaceDeclaration(node)) {
+      const extendedInterfaceDecl = node as base.ExtendedInterfaceDeclaration;
+      // If we were able to associate a variable declaration with the interface definition then the
+      // interface isn't actually anonymous.
+      return !extendedInterfaceDecl.classLikeVariableDeclaration;
+    } else if (this.trustJSTypes && ts.isClassLike(node)) {
+      // If the trust-js-types flag is set, @anonymous tags are emitted on all classes that don't
+      // have any constructors or any static members.
+      const hasConstructor = node.members.some((member: ts.TypeElement|ts.ClassElement) => {
+        return ts.isConstructorDeclaration(member) || ts.isConstructSignatureDeclaration(member);
+      });
+      const hasStatic = node.members.some(base.isStatic);
+      return !hasConstructor && !hasStatic;
+    }
+    return false;
   }
 
   maybeEmitJsAnnotation(node: ts.Node, {suppressUnneededPaths}: {suppressUnneededPaths: boolean}) {
     // No need to emit the annotations as an entity outside the code comment
     // will already have the same annotation.
     if (this.insideCodeComment) return;
 
-    if (this.isAnonymousInterface(node)) {
+    if (this.isAnonymous(node)) {
       this.emit('@anonymous');
       this.emit('@JS()');
       return;
@@ -433,7 +443,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
 
   constructor(
       tr: Transpiler, private fc: FacadeConverter, private enforceUnderscoreConventions: boolean,
-      private promoteFunctionLikeMembers: boolean) {
+      private promoteFunctionLikeMembers: boolean, private trustJSTypes: boolean) {
     super(tr);
   }
 
@@ -680,11 +690,11 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       } break;
       case ts.SyntaxKind.Constructor:
       case ts.SyntaxKind.ConstructSignature: {
-        let ctorDecl = <ts.ConstructorDeclaration>node;
+        const ctorDecl = <ts.ConstructorDeclaration>node;
         // Find containing class name.
         let classDecl = base.getEnclosingClass(ctorDecl);
         if (!classDecl) this.reportError(ctorDecl, 'cannot find outer class node');
-        let isAnonymous = this.isAnonymousInterface(classDecl);
+        const isAnonymous = this.isAnonymous(classDecl);
         if (isAnonymous) {
           this.emit('// Constructors on anonymous interfaces are not yet supported.\n');
           this.enterCodeComment();

lib/main.ts

@@ -50,6 +50,10 @@ export interface TranspilerOptions {
    * declarations are static.
    */
   explicitStatic?: boolean;
+  /**
+   * Emit anonymous tags on all classes that have neither constructors nor static members.
+   */
+  trustJSTypes?: boolean;
 
   /**
    * Experimental JS Interop specific option to promote properties with function
@@ -109,7 +113,8 @@ export class Transpiler {
     this.options = this.options || {};
     this.fc = new FacadeConverter(this, options.typingsRoot, options.generateHTML);
     this.declarationTranspiler = new DeclarationTranspiler(
-        this, this.fc, options.enforceUnderscoreConventions, options.promoteFunctionLikeMembers);
+        this, this.fc, options.enforceUnderscoreConventions, options.promoteFunctionLikeMembers,
+        options.trustJSTypes);
     this.transpilers = [
       new ModuleTranspiler(this, this.fc, options.moduleName),
       this.declarationTranspiler,

test/declaration_test.ts

@@ -950,6 +950,60 @@ abstract class MyCache implements CacheBase {
 }`);
     });
   });
+
+  describe('--trust-js-types', () => {
+    const trustJSTypesOpts = {failFast: true, trustJSTypes: true};
+    it('makes classes that have neither constructors nor static members anonymous when set', () => {
+      expectTranslate(
+          `declare class X {
+             a: number;
+             b: string;
+           }`,
+          trustJSTypesOpts)
+          .to.equal(`@anonymous
+@JS()
+class X {
+  // @Ignore
+  X.fakeConstructor$();
+  external num get a;
+  external set a(num v);
+  external String get b;
+  external set b(String v);
+}`);
+      expectTranslate(
+          `declare class X {
+             constructor();
+             a: number;
+             b: string;
+           }`,
+          trustJSTypesOpts)
+          .to.equal(`@JS()
+class X {
+  // @Ignore
+  X.fakeConstructor$();
+  external factory X();
+  external num get a;
+  external set a(num v);
+  external String get b;
+  external set b(String v);
+}`);
+    });
+    expectTranslate(
+        `declare class X {
+           static a: number;
+           static b: string;
+         }`,
+        trustJSTypesOpts)
+        .to.equal(`@JS()
+class X {
+  // @Ignore
+  X.fakeConstructor$();
+  external static num get a;
+  external static set a(num v);
+  external static String get b;
+  external static set b(String v);
+}`);
+  });
 });
 
 describe('single call signature interfaces', () => {

test/facade_converter_test.ts

@@ -128,9 +128,8 @@ external Thing get t;`);
 external get x;`);
       expectWithTypes('const x = [];').to.equal(`@JS()
 external get x;`);
-      expectWithTypes(
-          'class Person {}' +
-          'const x = new Person();')
+      expectWithTypes(`class Person {}
+                      const x = new Person();`)
           .to.equal(`@JS()
 class Person {
   // @Ignore