[flow][records] Disallow record names starting with lowercase 'a'-'z'

Summary:
Disallow record names starting with lowercase 'a'-'z'. We would have this as part of the style guide anyway, but update here:

- Record expressions (e.g. `foo {}`): do not parse at all
  - We want to future proof the syntax for new contextual keywords being added in TC39 proposals
  - Prevent parsing of record expressions in the middle of writing/editing existing constructs like `clas {}`
- Record declarations (e.g. `record foo {}`: add a Flow error
  - No syntax conflicts, so we parse and Flow error with an explanation

Changelog: [internal]

Reviewed By: SamChou19815

Differential Revision: D89772551

fbshipit-source-id: 9d5689cb4b77ef63c70a0300f9b4a197994e216c

Author: gkz

src/common/errors/error_codes.ml

@@ -136,6 +136,7 @@ type error_code =
   | ReassignEnum
   | ReassignImport
   | RecordBannedTypeUtil
+  | RecordInvalidName
   | RecordInvalidNew
   | RecordInvalidSyntax
   | ReferenceBeforeDeclaration
@@ -355,6 +356,7 @@ let string_of_code : error_code -> string = function
   | ReassignEnum -> "reassign-enum"
   | ReassignImport -> "reassign-import"
   | RecordBannedTypeUtil -> "record-banned-type-util"
+  | RecordInvalidName -> "record-invalid-name"
   | RecordInvalidNew -> "record-invalid-new"
   | RecordInvalidSyntax -> "record-invalid-syntax"
   | ReferenceBeforeDeclaration -> "reference-before-declaration"

src/parser/expression_parser.ml

@@ -837,15 +837,17 @@ module Expression
       let in_optional_chain = Option.is_some optional in
       call_cover ~allow_optional_chain ~in_optional_chain env start_loc (Cover_expr (loc, call))
     in
+    let is_a_to_z c = c >= 'a' && c <= 'z' in
     let should_parse_record env constructor =
       (parse_options env).records
       && (not (Peek.ith_is_line_terminator ~i:1 env))
       && (not (no_record env))
       &&
       match constructor with
-      | (_, Expression.Identifier _)
-      | (_, Expression.Member _) ->
+      | (_, Expression.Identifier (_, { Identifier.name; _ }))
+        when name != "" && not (is_a_to_z name.[0]) ->
         true
+      | (_, Expression.Member _) -> true
       | _ -> false
     in
     let parse_record env ~constructor ~targs =

src/parser/test/flow/records/expression-invalid-name.js

@@ -0,0 +1,2 @@
+// Not a `RecordExpression`
+clas {}

src/parser/test/flow/records/expression-invalid-name.options.json

@@ -0,0 +1,3 @@
+{
+  "records": true
+}

src/parser/test/flow/records/expression-invalid-name.tree.json

@@ -0,0 +1,41 @@
+{
+  "errors":[
+    {
+      "loc":{"source":null,"start":{"line":2,"column":5},"end":{"line":2,"column":6}},
+      "message":"Unexpected token `{`, expected the end of an expression statement (`;`)"
+    }
+  ],
+  "type":"Program",
+  "loc":{"source":null,"start":{"line":2,"column":0},"end":{"line":2,"column":7}},
+  "range":[28,35],
+  "body":[
+    {
+      "type":"ExpressionStatement",
+      "loc":{"source":null,"start":{"line":2,"column":0},"end":{"line":2,"column":4}},
+      "range":[28,32],
+      "expression":{
+        "type":"Identifier",
+        "loc":{"source":null,"start":{"line":2,"column":0},"end":{"line":2,"column":4}},
+        "range":[28,32],
+        "name":"clas",
+        "typeAnnotation":null,
+        "optional":false
+      },
+      "directive":null
+    },
+    {
+      "type":"BlockStatement",
+      "loc":{"source":null,"start":{"line":2,"column":5},"end":{"line":2,"column":7}},
+      "range":[33,35],
+      "body":[]
+    }
+  ],
+  "comments":[
+    {
+      "type":"Line",
+      "loc":{"source":null,"start":{"line":1,"column":0},"end":{"line":1,"column":27}},
+      "range":[0,27],
+      "value":" Not a `RecordExpression`"
+    }
+  ]
+}

src/typing/debug_js.ml

@@ -2059,6 +2059,8 @@ let dump_error_message =
       spf "EMatchInvalidInstancePattern (%s)" (string_of_aloc loc)
     | ERecordBannedTypeUtil { reason_op; reason_record } ->
       spf "ERecordBannedTypeUtil (%s) (%s)" (dump_reason cx reason_op) (dump_reason cx reason_record)
+    | ERecordInvalidName { name; loc } ->
+      spf "ERecordInvalidName { name = %s; loc = %s }" name (string_of_aloc loc)
     | ERecordInvalidNew { record_name; loc } ->
       spf "ERecordInvalidNew { record_name = %s; loc = %s }" record_name (string_of_aloc loc)
     | ERecordDeclarationInvalidSyntax { loc; _ } ->

src/typing/errors/error_message.ml

@@ -767,6 +767,10 @@ and 'loc t' =
       reason_op: 'loc virtual_reason;
       reason_record: 'loc virtual_reason;
     }
+  | ERecordInvalidName of {
+      loc: 'loc;
+      name: string;
+    }
   | ERecordInvalidNew of {
       loc: 'loc;
       record_name: string;
@@ -1889,6 +1893,7 @@ let rec map_loc_of_error_message (f : 'a -> 'b) : 'a t' -> 'b t' =
     ERecordBannedTypeUtil
       { reason_op = map_reason reason_op; reason_record = map_reason reason_record }
   | ERecordInvalidNew { loc; record_name } -> ERecordInvalidNew { loc = f loc; record_name }
+  | ERecordInvalidName { loc; name } -> ERecordInvalidName { loc = f loc; name }
   | ERecordDeclarationInvalidSyntax { loc; kind } ->
     let kind =
       match kind with
@@ -2302,6 +2307,7 @@ let util_use_op_of_msg nope util = function
   | EMatchInvalidInstancePattern _
   | ERecordBannedTypeUtil _
   | ERecordInvalidNew _
+  | ERecordInvalidName _
   | ERecordDeclarationInvalidSyntax _
   | EUndocumentedFeature _
   | EIllegalAssertOperator _ ->
@@ -2544,6 +2550,7 @@ let loc_of_msg : 'loc t' -> 'loc option = function
   | EMatchInvalidGuardedWildcard loc -> Some loc
   | EMatchInvalidIdentOrMemberPattern { loc; _ } -> Some loc
   | ERecordInvalidNew { loc; _ } -> Some loc
+  | ERecordInvalidName { loc; _ } -> Some loc
   | ERecordDeclarationInvalidSyntax { loc; _ } -> Some loc
   | EUndocumentedFeature { loc } -> Some loc
   | EDevOnlyRefinedLocInfo { refined_loc; refining_locs = _ } -> Some refined_loc
@@ -3766,6 +3773,7 @@ let friendly_message_of_msg = function
   | ERecordBannedTypeUtil { reason_op; reason_record } ->
     Normal (MessageRecordBannedTypeUtil { reason_op; reason_record })
   | ERecordInvalidNew { record_name; loc = _ } -> Normal (MessageRecordInvalidNew { record_name })
+  | ERecordInvalidName { name; loc = _ } -> Normal (MessageRecordInvalidName { name })
   | ERecordDeclarationInvalidSyntax { loc = _; kind } ->
     Normal (MessageRecordDeclarationInvalidSyntax kind)
   | EUndocumentedFeature { loc = _ } -> Normal MessageUndocumentedFeature
@@ -4178,6 +4186,7 @@ let error_code_of_message err : error_code option =
   | EMatchInvalidInstancePattern _ -> Some MatchInvalidPattern
   | ERecordBannedTypeUtil _ -> Some RecordBannedTypeUtil
   | ERecordInvalidNew _ -> Some RecordInvalidNew
+  | ERecordInvalidName _ -> Some RecordInvalidName
   | ERecordDeclarationInvalidSyntax _ -> Some RecordInvalidSyntax
   | EUndocumentedFeature _ -> Some UndocumentedFeature
   | EIllegalAssertOperator _ -> Some IllegalAssertOperator

src/typing/errors/flow_intermediate_error.ml

@@ -5465,6 +5465,12 @@ let to_printable_error :
         code (spf "%s {...}" record_name);
         text ".";
       ]
+    | MessageRecordInvalidName { name } ->
+      [
+        text "Invalid record name ";
+        code name;
+        text ". Record names cannot start with lowercase 'a' through 'z'.";
+      ]
     | MessageRecordDeclarationInvalidSyntax kind ->
       let msg_invalid_infix_equals =
         [text "Record declarations don't need the "; code "="; text ", remove it."]

src/typing/errors/flow_intermediate_error_types.ml

@@ -1198,6 +1198,7 @@ type 'loc message =
       reason_record: 'loc virtual_reason;
     }
   | MessageRecordInvalidNew of { record_name: string }
+  | MessageRecordInvalidName of { name: string }
   | MessageRecordDeclarationInvalidSyntax of 'loc record_declaration_invalid_syntax
   | MessageConstantCondition of {
       is_truthy: bool;

src/typing/statement.ml

@@ -1816,6 +1816,9 @@ module Make
           ~multiple_error_loc:name_loc
           invalid_syntax
           invalid_properties_syntax;
+        let is_a_to_z c = c >= 'a' && c <= 'z' in
+        if name != "" && is_a_to_z name.[0] then
+          Flow_js_utils.add_output cx (Error_message.ERecordInvalidName { loc = name_loc; name });
         let name = OrdinaryName name in
         let reason = DescFormat.instance_reason name name_loc in
         let tast_record_type = Type_env.read_declared_type cx reason name_loc in