[flow][records] Basic parsing of record declarations

Summary:
Basic parsing of record declarations (minus parsing of methods in records).

Changelog: [internal]

Reviewed By: SamChou19815

Differential Revision: D85729245

fbshipit-source-id: 2c2761dfe10b68e1e79381cd71a8c2476597e5c4

Author: gkz

packages/flow-parser/test/custom_ast_types.js

@@ -326,6 +326,26 @@ function custom_ast_types(fork) {
     .field('pattern', def('MatchPattern'))
     .field('target', or(def('Identifier'), def('MatchBindingPattern')));
 
+  def('RecordDeclaration')
+    .bases('Statement')
+    .build('id', 'typeParameters', 'implements', 'body')
+    .field('id', def('Identifier'))
+    .field('typeParameters', or(def('TypeParameterDeclaration'), null))
+    .field('implements', [def('RecordImplements')])
+    .field('body', def('RecordBody'));
+
+  def('RecordImplements').bases('ClassImplements');
+
+  def('RecordBody')
+    .build('body')
+    .field('body', [or(def('RecordProperty'), def('Method'))]);
+
+  def('RecordProperty')
+    .build('key', 'typeAnnotation', 'defaultValue')
+    .field('key', def('Identifier'))
+    .field('typeAnnotation', def('TypeAnnotation'))
+    .field('defaultValue', or(def('Expression'), null));
+
   /////////
   // es2018
   /////////

src/parser/comment_attachment.ml

@@ -575,6 +575,8 @@ let statement_add_comments
       Labeled { s with Labeled.comments = merge_comments comments }
     | Match ({ Match.comments; _ } as s) ->
       Match { s with Match.comments = merge_comments comments }
+    | RecordDeclaration ({ RecordDeclaration.comments; _ } as s) ->
+      RecordDeclaration { s with RecordDeclaration.comments = merge_comments comments }
     | Return ({ Return.comments; _ } as s) ->
       Return { s with Return.comments = merge_comments comments }
     | Switch ({ Switch.comments; _ } as s) ->

src/parser/estree_translator.ml

@@ -178,6 +178,47 @@ with type t = Impl.t = struct
           "SwitchStatement"
           loc
           [("discriminant", expression discriminant); ("cases", array_of_list case cases)]
+      | (loc, RecordDeclaration { RecordDeclaration.id; tparams; implements; body; comments }) ->
+        let record_property (loc, { RecordDeclaration.Property.key; annot; default_value; comments })
+            =
+          let key = identifier key in
+          node
+            ?comments
+            "RecordProperty"
+            loc
+            [
+              ("key", key);
+              ("typeAnnotation", type_annotation annot);
+              ("defaultValue", option expression default_value);
+            ]
+        in
+
+        let record_element element =
+          let open RecordDeclaration.Body in
+          match element with
+          | Property prop -> record_property prop
+          | Method meth -> class_method meth
+        in
+        let record_body (loc, { RecordDeclaration.Body.body; comments }) =
+          node ?comments "RecordBody" loc [("body", array_of_list record_element body)]
+        in
+        let record_implements = implements_helper "RecordImplements" in
+        let implements =
+          match implements with
+          | Some (_, { Class.Implements.interfaces; comments = _ }) ->
+            array_of_list record_implements interfaces
+          | None -> array []
+        in
+        node
+          ?comments
+          "RecordDeclaration"
+          loc
+          [
+            ("id", identifier id);
+            ("typeParameters", option type_parameter_declaration tparams);
+            ("implements", implements);
+            ("body", record_body body);
+          ]
       | (loc, Return { Return.argument; comments; return_out = _ }) ->
         node ?comments "ReturnStatement" loc [("argument", option expression argument)]
       | (loc, Throw { Throw.argument; comments }) ->
@@ -1247,8 +1288,9 @@ with type t = Impl.t = struct
         ]
     and class_decorator (loc, { Class.Decorator.expression = expr; comments }) =
       node ?comments "Decorator" loc [("expression", expression expr)]
-    and class_implements (loc, { Class.Implements.Interface.id; targs }) =
-      node "ClassImplements" loc [("id", identifier id); ("typeParameters", option type_args targs)]
+    and implements_helper node_type (loc, { Class.Implements.Interface.id; targs }) =
+      node node_type loc [("id", identifier id); ("typeParameters", option type_args targs)]
+    and class_implements node = implements_helper "ClassImplements" node
     and class_body (loc, { Class.Body.body; comments }) =
       node ?comments "ClassBody" loc [("body", array_of_list class_element body)]
     and class_element =

src/parser/flow_ast.ml

@@ -1076,6 +1076,43 @@ and Statement : sig
     [@@deriving show]
   end
 
+  module RecordDeclaration : sig
+    module Property : sig
+      type ('M, 'T) t = 'T * ('M, 'T) t'
+
+      and ('M, 'T) t' = {
+        key: ('M, 'T) Identifier.t;
+        annot: ('M, 'T) Type.annotation;
+        default_value: ('M, 'T) Expression.t option;
+        comments: ('M, unit) Syntax.t option;
+      }
+      [@@deriving show]
+    end
+
+    module Body : sig
+      type ('M, 'T) t = 'M * ('M, 'T) t'
+
+      and ('M, 'T) t' = {
+        body: ('M, 'T) element list;
+        comments: ('M, unit) Syntax.t option;
+      }
+
+      and ('M, 'T) element =
+        | Method of ('M, 'T) Class.Method.t
+        | Property of ('M, 'T) Property.t
+      [@@deriving show]
+    end
+
+    type ('M, 'T) t = {
+      id: ('M, 'T) Identifier.t;
+      tparams: ('M, 'T) Type.TypeParams.t option;
+      implements: ('M, 'T) Class.Implements.t option;
+      body: ('M, 'T) Body.t;
+      comments: ('M, unit) Syntax.t option;
+    }
+    [@@deriving show]
+  end
+
   module DeclareClass : sig
     type ('M, 'T) t = {
       id: ('M, 'T) Identifier.t;
@@ -1320,6 +1357,7 @@ and Statement : sig
     | InterfaceDeclaration of ('M, 'T) Interface.t
     | Labeled of ('M, 'T) Labeled.t
     | Match of ('M, 'T) match_statement
+    | RecordDeclaration of ('M, 'T) RecordDeclaration.t
     | Return of ('M, 'T) Return.t
     | Switch of ('M, 'T) Switch.t
     | Throw of ('M, 'T) Throw.t

src/parser/flow_ast_mapper.ml

@@ -92,6 +92,7 @@ type type_params_context =
   | FunctionTypeTP
   | InferTP
   | ObjectMappedTypeTP
+  | RecordTP
 
 class ['loc] mapper =
   object (this)
@@ -190,6 +191,10 @@ class ['loc] mapper =
       | (loc, Match x) -> id_loc this#match_statement loc x stmt (fun x -> (loc, Match x))
       | (loc, OpaqueType otype) ->
         id_loc this#opaque_type loc otype stmt (fun otype -> (loc, OpaqueType otype))
+      | (loc, RecordDeclaration record) ->
+        id_loc this#record_declaration loc record stmt (fun record ->
+            (loc, RecordDeclaration record)
+        )
       | (loc, Return ret) -> id_loc this#return loc ret stmt (fun ret -> (loc, Return ret))
       | (loc, Switch switch) ->
         id_loc this#switch loc switch stmt (fun switch -> (loc, Switch switch))
@@ -3280,6 +3285,62 @@ class ['loc] mapper =
       else
         (loc, { argument = argument'; comments = comments' })
 
+    method record_declaration _loc (record : ('loc, 'loc) Ast.Statement.RecordDeclaration.t) =
+      let open Ast.Statement.RecordDeclaration in
+      let { id; tparams; implements; body; comments } = record in
+      let id' = this#identifier id in
+      let tparams' = map_opt (this#type_params ~kind:RecordTP) tparams in
+      let implements' = map_opt this#class_implements implements in
+      let body' = this#record_body body in
+      let comments' = this#syntax_opt comments in
+      if
+        id == id'
+        && tparams == tparams'
+        && implements == implements'
+        && body == body'
+        && comments == comments'
+      then
+        record
+      else
+        {
+          id = id';
+          tparams = tparams';
+          implements = implements';
+          body = body';
+          comments = comments';
+        }
+
+    method record_body (record_body : ('loc, 'loc) Ast.Statement.RecordDeclaration.Body.t) =
+      let open Ast.Statement.RecordDeclaration.Body in
+      let (loc, { body; comments }) = record_body in
+      let body' = map_list this#record_element body in
+      let comments' = this#syntax_opt comments in
+      if body == body' && comments == comments' then
+        record_body
+      else
+        (loc, { body = body'; comments = comments' })
+
+    method record_element (element : ('loc, 'loc) Ast.Statement.RecordDeclaration.Body.element) =
+      let open Ast.Statement.RecordDeclaration.Body in
+      match element with
+      | Method (loc, meth) ->
+        id_loc this#class_method loc meth element (fun meth -> Method (loc, meth))
+      | Property (loc, prop) ->
+        id_loc this#record_property loc prop element (fun prop -> Property (loc, prop))
+
+    method record_property _loc (prop : ('loc, 'loc) Ast.Statement.RecordDeclaration.Property.t') =
+      let open Ast.Statement.RecordDeclaration.Property in
+      let { key; annot; default_value; comments } = prop in
+      let key' = this#identifier key in
+      let annot' = this#type_annotation annot in
+      let default_value' = map_opt this#expression default_value in
+      let comments' = this#syntax_opt comments in
+      if key' == key && annot' == annot && default_value' == default_value && comments' == comments
+      then
+        prop
+      else
+        { key = key'; annot = annot'; default_value = default_value'; comments = comments' }
+
     method return _loc (stmt : ('loc, 'loc) Ast.Statement.Return.t) =
       let open Ast.Statement.Return in
       let { argument; comments; return_out } = stmt in

src/parser/flow_ast_utils.ml

@@ -378,6 +378,7 @@ let acceptable_statement_in_declaration_context ~in_declare_namespace =
   | If _ -> Error "if"
   | Labeled _ -> Error "labeled"
   | Match _ -> Error "match"
+  | RecordDeclaration _ -> Error "record declaration"
   | Return _ -> Error "return"
   | Switch _ -> Error "switch"
   | Throw _ -> Error "throw"
@@ -449,6 +450,7 @@ let rec is_type_only_declaration_statement (_, stmt') =
     | If _
     | Labeled _
     | Match _
+    | RecordDeclaration _
     | Return _
     | Switch _
     | Throw _

src/parser/flow_lexer.ml

@@ -903,6 +903,7 @@ let token (env : Lex_env.t) lexbuf : result =
     | "private" -> Token (env, T_PRIVATE)
     | "protected" -> Token (env, T_PROTECTED)
     | "public" -> Token (env, T_PUBLIC)
+    | "record" -> Token (env, T_RECORD)
     | "return" -> Token (env, T_RETURN)
     | "static" -> Token (env, T_STATIC)
     | "super" -> Token (env, T_SUPER)

src/parser/flow_parser_js.ml

@@ -68,6 +68,7 @@ let parse_options jsopts =
     components = bool_opt defaults.components jsopts "components";
     enums = bool_opt defaults.enums jsopts "enums";
     pattern_matching = bool_opt defaults.pattern_matching jsopts "pattern_matching";
+    records = bool_opt defaults.records jsopts "records";
     esproposal_decorators = bool_opt defaults.esproposal_decorators jsopts "esproposal_decorators";
     types = bool_opt defaults.types jsopts "types";
     use_strict = bool_opt defaults.use_strict jsopts "use_strict";

src/parser/object_parser.ml

@@ -1169,4 +1169,91 @@ module Object
 
   let class_expression =
     with_loc (fun env -> Ast.Expression.Class (_class env ~optional_id:true ~expression:true))
+
+  let record_body =
+    let open Statement.RecordDeclaration in
+    let rec elements env acc =
+      match Peek.token env with
+      | T_EOF
+      | T_RCURLY ->
+        List.rev acc
+      | _ ->
+        let leading = Peek.comments env in
+        let key = identifier_name env in
+        let (key_loc, _) = key in
+        (match Peek.token env with
+        (* TODO: records - methods parsing*)
+        | T_COLON ->
+          let prop =
+            with_loc
+              ~start_loc:key_loc
+              (fun env ->
+                let annot = Type.annotation env in
+                let default_value =
+                  if Eat.maybe env T_ASSIGN then
+                    Some (Expression.assignment env)
+                  else
+                    None
+                in
+                (match Peek.token env with
+                | T_EOF
+                | T_RCURLY ->
+                  ()
+                | _ -> Expect.token env T_COMMA);
+                let comments = Flow_ast_utils.mk_comments_opt ~leading () in
+                { Property.key; annot; default_value; comments })
+              env
+          in
+          elements env (Body.Property prop :: acc)
+        | _ ->
+          (* TODO: records - error *)
+          elements env acc)
+    in
+    with_loc (fun env ->
+        let leading = Peek.comments env in
+        if Eat.maybe env T_LCURLY then (
+          let body = elements env [] in
+          let trailing =
+            match Peek.token env with
+            | T_RCURLY
+            | T_EOF ->
+              Eat.trailing_comments env
+            | _ when Peek.is_line_terminator env -> Eat.comments_until_next_line env
+            | _ -> []
+          in
+          Expect.token env T_RCURLY;
+          { Body.body; comments = Flow_ast_utils.mk_comments_opt ~leading ~trailing () }
+        ) else (
+          Expect.error env T_LCURLY;
+          { Body.body = []; comments = None }
+        )
+    )
+
+  let record_declaration =
+    with_loc (fun env ->
+        let leading = Peek.comments env in
+        Expect.token env T_RECORD;
+        let id = Parse.identifier env in
+        let tparams =
+          match Type.type_params env with
+          | None -> None
+          | Some tparams ->
+            let { remove_trailing; _ } = trailing_and_remover env in
+            Some
+              (remove_trailing tparams (fun remover tparams ->
+                   remover#type_params ~kind:Flow_ast_mapper.RecordTP tparams
+               )
+              )
+        in
+        let implements =
+          if Peek.token env = T_IMPLEMENTS then
+            Some (class_implements_remove_trailing env (class_implements env ~attach_leading:true))
+          else
+            None
+        in
+        let body = record_body env in
+        let comments = Flow_ast_utils.mk_comments_opt ~leading () in
+        Ast.Statement.RecordDeclaration
+          { Ast.Statement.RecordDeclaration.id; tparams; implements; body; comments }
+    )
 end

src/parser/parser_common.ml

@@ -149,6 +149,8 @@ module type OBJECT = sig
   val class_implements : env -> attach_leading:bool -> (Loc.t, Loc.t) Class.Implements.t
 
   val decorator_list : env -> (Loc.t, Loc.t) Class.Decorator.t list
+
+  val record_declaration : env -> (Loc.t, Loc.t) Statement.t
 end
 
 module type JSX = sig
@@ -378,6 +380,7 @@ let identifier_name_raw env =
     | T_OPAQUE -> "opaque"
     | T_ANY_TYPE -> "any"
     | T_MATCH -> "match"
+    | T_RECORD -> "record"
     | T_MIXED_TYPE -> "mixed"
     | T_EMPTY_TYPE -> "empty"
     | T_BOOLEAN_TYPE BOOL -> "bool"