No exact objects with indexers

src/__tests__/__snapshots__/classes.spec.ts.snap

@@ -57,7 +57,6 @@ declare class Observable<T> mixins Subscribable<T> {
   static +jump?: () => void;
   cfnProperties: {
     [key: string]: any,
-    ...
   };
   static fooGet: string;
 }

src/__tests__/__snapshots__/indexers.spec.ts.snap

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`should handle indexers 1`] = `
+"declare type Map = {
+  [key: string]: number,
+};
+"
+`;
+
+exports[`should handle indexers 2`] = `
+"declare type Map = {
+  [key: string]: number,
+};
+"
+`;

src/__tests__/indexers.spec.ts

@@ -0,0 +1,24 @@
+import { compiler, beautify } from "..";
+import "../test-matchers";
+
+it("should handle indexers", () => {
+  const ts = `
+type Map = {
+  [key: string]: number
+}
+`;
+  {
+    const result = compiler.compileDefinitionString(ts, { quiet: true });
+    expect(beautify(result)).toMatchSnapshot();
+    expect(result).toBeValidFlowTypeDeclarations();
+  }
+
+  {
+    const result = compiler.compileDefinitionString(ts, {
+      quiet: true,
+      inexact: false,
+    });
+    expect(beautify(result)).toMatchSnapshot();
+    expect(result).toBeValidFlowTypeDeclarations();
+  }
+});

src/printers/declarations.ts

@@ -84,7 +84,13 @@ export const interfaceType = <T>(
     }
   }
 
-  if (isType && isInexact) {
+  const hasIndexSignature = node.members.some(member =>
+    ts.isIndexSignatureDeclaration(member),
+  );
+
+  // If an index signature is present in our type, we probably don't want to
+  // provide the trailing "...", since it will be ignored by Flow anyway.
+  if (isType && isInexact && !hasIndexSignature) {
     members.push("...\n");
   } else if (members.length > 0) {
     members.push("\n");
@@ -98,6 +104,18 @@ export const interfaceType = <T>(
   if (!ts.isTypeLiteralNode(node)) {
     return `{${inner}}`;
   }
+
+  // If a type contains an index signature (e.g. `[key: string]: number`), then
+  // we want to treat it as inexact no matter what, otherwise we may generate a
+  // Flow type like `{|[k: string]: any|}` which is invalid in Flow prior to
+  // v0.126.0 (source: https://github.com/facebook/flow/blob/main/Changelog.md#01260)
+  //
+  // It should also be safe to assume that if an index signature is present, the
+  // equivalent human-authored Flow type would be inexact.
+  if (hasIndexSignature) {
+    return `{${inner}}`;
+  }
+
   return isInexact ? `{${inner}}` : `{|${inner}|}`;
 };