[flow][tslib] Support export = ... and import foo = ...

Summary:
This adds support for two [TypeScript-style](https://www.typescriptlang.org/docs/handbook/modules/reference.html#export--and-import--require) syntactic forms behind the `tslib_syntax` flag:

1. `export = <expression>` (ExportAssignment) — the equivalent of `module.exports = ...`

2. `import <id> = require("<module>")` and `import <id> = <QualifiedName>` (ImportEqualsDeclaration) — the equivalent of `const <id> = require(...)`

Changelog: [internal]

Reviewed By: SamChou19815

Differential Revision: D92915376

fbshipit-source-id: 70f67a14dce1abbce6d2978a3507c83f3aa53f60

Author: gkz

src/analysis/env_builder/name_def.ml

@@ -2646,6 +2646,34 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
         default;
       super#import_declaration loc decl
 
+    method! import_equals_declaration _loc decl =
+      let open Ast.Statement.ImportEqualsDeclaration in
+      let {
+        id = (id_loc, { Ast.Identifier.name = local_name; _ });
+        module_reference;
+        import_kind;
+        is_export = _;
+        comments = _;
+      } =
+        decl
+      in
+      (match module_reference with
+      | ExternalModuleReference (source_loc, { Ast.StringLiteral.value = source; _ }) ->
+        let import_reason =
+          mk_reason
+            (RDefaultImportedType (local_name, Flow_import_specifier.userland source))
+            id_loc
+        in
+        this#add_ordinary_binding
+          id_loc
+          import_reason
+          (Import { import_kind; source; source_loc; import = Default local_name })
+      | Identifier _ ->
+        (* import Foo = A.B.C: qualified name access is not resolved through
+           name_def/env_resolution. The binding is handled by the type_sig layer. *)
+        ());
+      decl
+
     method! call loc _ = fail loc "Should be visited by visit_call_expression"
 
     method private visit_call_expression ~hints ~cond ~visit_callee loc expr =

src/analysis/hoister.ml

@@ -79,6 +79,7 @@ class ['loc] lexical_hoister ~(enable_enums : bool) =
       | (_, ExportNamedDeclaration _)
       | (_, ExportDefaultDeclaration _)
       | (_, ImportDeclaration _)
+      | (_, ImportEqualsDeclaration _)
       | (_, Labeled _) ->
         super#statement stmt
       | (_, FunctionDeclaration _)
@@ -98,6 +99,7 @@ class ['loc] lexical_hoister ~(enable_enums : bool) =
       | (_, DeclareOpaqueType _)
       | (_, DoWhile _)
       | (_, Empty _)
+      | (_, ExportAssignment _)
       | (_, Expression _)
       | (_, For _)
       | (_, ForIn _)
@@ -378,6 +380,21 @@ class ['loc] hoister ~(enable_enums : bool) ~(with_types : bool) =
         decl
       | _ -> super#import_declaration loc decl
 
+    method! import_equals_declaration _loc decl =
+      let open Ast.Statement.ImportEqualsDeclaration in
+      let { id; import_kind; _ } = decl in
+      let open Ast.Statement.ImportDeclaration in
+      begin
+        match import_kind with
+        | ImportValue -> this#add_const_binding ~kind:Bindings.Import id
+        | ImportType
+        | ImportTypeof
+          when with_types ->
+          this#add_type_binding ~imported:true id
+        | _ -> ()
+      end;
+      decl
+
     method! import_named_specifier
         ~import_kind (specifier : ('loc, 'loc) Ast.Statement.ImportDeclaration.named_specifier) =
       let open Ast.Statement.ImportDeclaration in

src/parser/comment_attachment.ml

@@ -568,6 +568,8 @@ let statement_add_comments
         { s with ExportDefaultDeclaration.comments = merge_comments comments }
     | ExportNamedDeclaration ({ ExportNamedDeclaration.comments; _ } as s) ->
       ExportNamedDeclaration { s with ExportNamedDeclaration.comments = merge_comments comments }
+    | ExportAssignment ({ ExportAssignment.comments; _ } as s) ->
+      ExportAssignment { s with ExportAssignment.comments = merge_comments comments }
     | Expression ({ Expression.comments; _ } as s) ->
       Expression { s with Expression.comments = merge_comments comments }
     | For ({ For.comments; _ } as s) -> For { s with For.comments = merge_comments comments }
@@ -580,6 +582,8 @@ let statement_add_comments
     | If ({ If.comments; _ } as s) -> If { s with If.comments = merge_comments comments }
     | ImportDeclaration ({ ImportDeclaration.comments; _ } as s) ->
       ImportDeclaration { s with ImportDeclaration.comments = merge_comments comments }
+    | ImportEqualsDeclaration ({ ImportEqualsDeclaration.comments; _ } as s) ->
+      ImportEqualsDeclaration { s with ImportEqualsDeclaration.comments = merge_comments comments }
     | InterfaceDeclaration ({ Interface.comments; _ } as s) ->
       InterfaceDeclaration { s with Interface.comments = merge_comments comments }
     | Labeled ({ Labeled.comments; _ } as s) ->

src/parser/estree_translator.ml

@@ -432,6 +432,8 @@ with type t = Impl.t = struct
             ("declaration", declaration);
             ("exportKind", string (string_of_export_kind Statement.ExportValue));
           ]
+      | (loc, ExportAssignment { ExportAssignment.expression = expr; comments }) ->
+        node ?comments "ExportAssignment" loc [("expression", expression expr)]
       | ( loc,
           ImportDeclaration
             { ImportDeclaration.specifiers; default; import_kind; source; attributes; comments }
@@ -473,6 +475,49 @@ with type t = Impl.t = struct
            ]
           @ attributes_json
           )
+      | ( loc,
+          ImportEqualsDeclaration
+            {
+              ImportEqualsDeclaration.id = ident;
+              module_reference;
+              import_kind;
+              is_export;
+              comments;
+            }
+        ) ->
+        let module_reference_json =
+          let open ImportEqualsDeclaration in
+          match module_reference with
+          | ExternalModuleReference (annot_loc, lit) ->
+            node
+              "ExternalModuleReference"
+              annot_loc
+              [("expression", string_literal (annot_loc, lit))]
+          | Identifier git ->
+            let open Type.Generic.Identifier in
+            let generic_id = function
+              | Unqualified id -> identifier id
+              | Qualified q -> generic_type_qualified_identifier q
+              | ImportTypeAnnot it -> import_type it
+            in
+            generic_id git
+        in
+        let import_kind_str =
+          match import_kind with
+          | ImportDeclaration.ImportType -> "type"
+          | ImportDeclaration.ImportTypeof -> "typeof"
+          | ImportDeclaration.ImportValue -> "value"
+        in
+        node
+          ?comments
+          "ImportEqualsDeclaration"
+          loc
+          [
+            ("id", identifier ident);
+            ("moduleReference", module_reference_json);
+            ("importKind", string import_kind_str);
+            ("isExport", bool is_export);
+          ]
     and expression =
       let open Expression in
       function

src/parser/flow_ast.ml

@@ -1236,6 +1236,14 @@ and Statement : sig
     [@@deriving show]
   end
 
+  module ExportAssignment : sig
+    type ('M, 'T) t = {
+      expression: ('M, 'T) Expression.t;
+      comments: ('M, unit) Syntax.t option;
+    }
+    [@@deriving show]
+  end
+
   module ExportNamedDeclaration : sig
     module ExportSpecifier : sig
       type ('M, 'T) t = 'M * ('M, 'T) t'
@@ -1361,6 +1369,21 @@ and Statement : sig
     [@@deriving show]
   end
 
+  module ImportEqualsDeclaration : sig
+    type ('M, 'T) module_reference =
+      | ExternalModuleReference of ('T * 'M StringLiteral.t)
+      | Identifier of ('M, 'T) Type.Generic.Identifier.t
+
+    and ('M, 'T) t = {
+      id: ('M, 'T) Identifier.t;
+      module_reference: ('M, 'T) module_reference;
+      import_kind: ImportDeclaration.import_kind;
+      is_export: bool;
+      comments: ('M, unit) Syntax.t option;
+    }
+    [@@deriving show]
+  end
+
   module Expression : sig
     type ('M, 'T) t = {
       expression: ('M, 'T) Expression.t;
@@ -1404,13 +1427,15 @@ and Statement : sig
     | EnumDeclaration of ('M, 'T) EnumDeclaration.t
     | ExportDefaultDeclaration of ('M, 'T) ExportDefaultDeclaration.t
     | ExportNamedDeclaration of ('M, 'T) ExportNamedDeclaration.t
+    | ExportAssignment of ('M, 'T) ExportAssignment.t
     | Expression of ('M, 'T) Expression.t
     | For of ('M, 'T) For.t
     | ForIn of ('M, 'T) ForIn.t
     | ForOf of ('M, 'T) ForOf.t
     | FunctionDeclaration of ('M, 'T) Function.t
     | If of ('M, 'T) If.t
     | ImportDeclaration of ('M, 'T) ImportDeclaration.t
+    | ImportEqualsDeclaration of ('M, 'T) ImportEqualsDeclaration.t
     | InterfaceDeclaration of ('M, 'T) Interface.t
     | Labeled of ('M, 'T) Labeled.t
     | Match of ('M, 'T) match_statement

src/parser/flow_ast_mapper.ml

@@ -168,6 +168,8 @@ class ['loc] mapper =
         id_loc this#export_named_declaration loc decl stmt (fun decl ->
             (loc, ExportNamedDeclaration decl)
         )
+      | (loc, ExportAssignment assign) ->
+        id_loc this#export_assignment loc assign stmt (fun assign -> (loc, ExportAssignment assign))
       | (loc, Expression expr) ->
         id_loc this#expression_statement loc expr stmt (fun expr -> (loc, Expression expr))
       | (loc, For for_stmt) ->
@@ -182,6 +184,10 @@ class ['loc] mapper =
         id_loc this#if_statement loc if_stmt stmt (fun if_stmt -> (loc, If if_stmt))
       | (loc, ImportDeclaration decl) ->
         id_loc this#import_declaration loc decl stmt (fun decl -> (loc, ImportDeclaration decl))
+      | (loc, ImportEqualsDeclaration decl) ->
+        id_loc this#import_equals_declaration loc decl stmt (fun decl ->
+            (loc, ImportEqualsDeclaration decl)
+        )
       | (loc, InterfaceDeclaration stuff) ->
         id_loc this#interface_declaration loc stuff stmt (fun stuff ->
             (loc, InterfaceDeclaration stuff)
@@ -1321,6 +1327,16 @@ class ['loc] mapper =
       else
         { value; raw; comments = comments' }
 
+    method export_assignment _loc (assign : ('loc, 'loc) Ast.Statement.ExportAssignment.t) =
+      let open Ast.Statement.ExportAssignment in
+      let { expression = expr; comments } = assign in
+      let expr' = this#expression expr in
+      let comments' = this#syntax_opt comments in
+      if expr == expr' && comments == comments' then
+        assign
+      else
+        { expression = expr'; comments = comments' }
+
     method expression_statement _loc (stmt : ('loc, 'loc) Ast.Statement.Expression.t) =
       let open Ast.Statement.Expression in
       let { expression = expr; directive; comments } = stmt in
@@ -2387,6 +2403,43 @@ class ['loc] mapper =
       else
         { value; raw; comments = comments' }
 
+    method import_equals_declaration
+        _loc (decl : ('loc, 'loc) Ast.Statement.ImportEqualsDeclaration.t) =
+      let open Ast.Statement.ImportEqualsDeclaration in
+      let { id = ident; module_reference; import_kind; is_export; comments } = decl in
+      let ident' =
+        let open Ast.Statement.ImportDeclaration in
+        match import_kind with
+        | ImportType
+        | ImportTypeof ->
+          this#binding_type_identifier ident
+        | ImportValue -> this#pattern_identifier ~kind:Ast.Variable.Let ident
+      in
+      let module_reference' = this#import_equals_module_reference module_reference in
+      let comments' = this#syntax_opt comments in
+      if ident == ident' && module_reference == module_reference' && comments == comments' then
+        decl
+      else
+        {
+          id = ident';
+          module_reference = module_reference';
+          import_kind;
+          is_export;
+          comments = comments';
+        }
+
+    method import_equals_module_reference
+        (ref : ('loc, 'loc) Ast.Statement.ImportEqualsDeclaration.module_reference) =
+      let open Ast.Statement.ImportEqualsDeclaration in
+      match ref with
+      | ExternalModuleReference (annot, lit) ->
+        let lit' = this#string_literal lit in
+        if lit == lit' then
+          ref
+        else
+          ExternalModuleReference (annot, lit')
+      | Identifier ident -> id this#generic_identifier_type ident ref (fun ident -> Identifier ident)
+
     method import_attributes
         _loc (attrs : ('loc, 'loc) Ast.Statement.ImportDeclaration.import_attribute list) =
       map_list this#import_attribute attrs

src/parser/flow_ast_utils.ml

@@ -447,7 +447,9 @@ let acceptable_statement_in_declaration_context ~in_declare_namespace =
   | DeclareVariable _
   | Empty _
   | EnumDeclaration _
+  | ExportAssignment _
   | ExportNamedDeclaration { ExportNamedDeclaration.export_kind = ExportType; _ }
+  | ImportEqualsDeclaration _
   | InterfaceDeclaration _
   | OpaqueType _
   | TypeAlias _ ->
@@ -486,13 +488,15 @@ let rec is_type_only_declaration_statement (_, stmt') =
     | Debugger _
     | DoWhile _
     | EnumDeclaration _
+    | ExportAssignment _
     | ExportDefaultDeclaration _
     | Expression _
     | For _
     | ForIn _
     | ForOf _
     | FunctionDeclaration _
     | If _
+    | ImportEqualsDeclaration _
     | Labeled _
     | Match _
     | RecordDeclaration _

src/parser/parser_flow.ml

@@ -143,10 +143,11 @@ let check_for_duplicate_exports =
             | DeclareExportDeclaration _ | DeclareFunction _ | DeclareInterface _ | DeclareModule _
             | DeclareModuleExports _ | DeclareNamespace _ | DeclareTypeAlias _ | DeclareOpaqueType _
             | DeclareVariable _ | DoWhile _ | Empty _ | ExportDefaultDeclaration _
-            | ExportNamedDeclaration _ | Expression _ | For _ | ForIn _ | ForOf _
+            | ExportNamedDeclaration _ | ExportAssignment _ | Expression _ | For _ | ForIn _
+            | ForOf _
             | FunctionDeclaration { Function.id = None; _ }
-            | If _ | ImportDeclaration _ | Labeled _ | Match _ | Return _ | Switch _ | Throw _
-            | Try _ | While _ | With _ ))
+            | If _ | ImportDeclaration _ | ImportEqualsDeclaration _ | Labeled _ | Match _
+            | Return _ | Switch _ | Throw _ | Try _ | While _ | With _ ))
         ) ->
         (* these don't export names -- some are invalid, but the AST allows them *)
         seen)
@@ -166,10 +167,11 @@ let check_for_duplicate_exports =
           | DeclareComponent _ | DeclareEnum _ | DeclareExportDeclaration _ | DeclareFunction _
           | DeclareInterface _ | DeclareModule _ | DeclareModuleExports _ | DeclareNamespace _
           | DeclareTypeAlias _ | DeclareOpaqueType _ | DeclareVariable _ | DoWhile _ | Empty _
-          | EnumDeclaration _ | Expression _ | For _ | ForIn _ | ForOf _ | FunctionDeclaration _
-          | ComponentDeclaration _ | If _ | ImportDeclaration _ | InterfaceDeclaration _ | Labeled _
-          | Match _ | RecordDeclaration _ | Return _ | Switch _ | Throw _ | Try _ | TypeAlias _
-          | OpaqueType _ | VariableDeclaration _ | While _ | With _ ))
+          | EnumDeclaration _ | ExportAssignment _ | Expression _ | For _ | ForIn _ | ForOf _
+          | FunctionDeclaration _ | ComponentDeclaration _ | If _ | ImportDeclaration _
+          | ImportEqualsDeclaration _ | InterfaceDeclaration _ | Labeled _ | Match _
+          | RecordDeclaration _ | Return _ | Switch _ | Throw _ | Try _ | TypeAlias _ | OpaqueType _
+          | VariableDeclaration _ | While _ | With _ ))
       ) ->
       seen
   in