Private fields

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1473 matching lines @@
 enum ParserFlag {
   kAllowLazy,
   kAllowNatives,
   kAllowHarmonyFunctionSent,
   kAllowHarmonyRestrictiveDeclarations,
   kAllowHarmonyForIn,
   kAllowHarmonyAsyncAwait,
   kAllowHarmonyRestrictiveGenerators,
   kAllowHarmonyTrailingCommas,
   kAllowHarmonyClassFields,
+  kAllowHarmonyPrivateClassFields,
 };
 
 enum ParserSyncTestResult {
   kSuccessOrError,
   kSuccess,
   kError
 };
 
 template <typename Traits>
 void SetParserFlags(i::ParserBase<Traits>* parser,
                     i::EnumSet<ParserFlag> flags) {
   parser->set_allow_lazy(flags.Contains(kAllowLazy));
   parser->set_allow_natives(flags.Contains(kAllowNatives));
   parser->set_allow_harmony_function_sent(
       flags.Contains(kAllowHarmonyFunctionSent));
   parser->set_allow_harmony_restrictive_declarations(
       flags.Contains(kAllowHarmonyRestrictiveDeclarations));
   parser->set_allow_harmony_for_in(flags.Contains(kAllowHarmonyForIn));
   parser->set_allow_harmony_async_await(
       flags.Contains(kAllowHarmonyAsyncAwait));
   parser->set_allow_harmony_restrictive_generators(
       flags.Contains(kAllowHarmonyRestrictiveGenerators));
   parser->set_allow_harmony_trailing_commas(
       flags.Contains(kAllowHarmonyTrailingCommas));
   parser->set_allow_harmony_class_fields(
       flags.Contains(kAllowHarmonyClassFields));
+  parser->set_allow_harmony_private_class_fields(
+      flags.Contains(kAllowHarmonyPrivateClassFields));
 }
 
 
 void TestParserSyncWithFlags(i::Handle<i::String> source,
                              i::EnumSet<ParserFlag> flags,
                              ParserSyncTestResult result,
                              bool is_module = false,
                              bool test_preparser = true) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
@@ skipping 3190 matching lines @@
     NULL
   };
   // clang-format on
 
   static const ParserFlag with_async[] = {kAllowHarmonyClassFields,
                                           kAllowHarmonyAsyncAwait};
   RunParserSyncTest(context_data, async_data, kError, NULL, 0, with_async,
                     arraysize(with_async));
 }
 
+TEST(ClassPrivatesNoErrors) {
+  // clang-format off
+  // Tests proposed class private fields syntax.
+  const char* class_body_contexts[][2] = {{"(class {", "});"},
+                                   {"(class extends Base {", "});"},
+                                   {"class C {", "}"},
+                                   {"class C extends Base {", "}"},
+                                   {NULL, NULL}};
+  const char* class_body_data[] = {
+    // Basic syntax
+    "#a = 0;",
+    "#a = 0; #b",
+    "#a = 0; b(){}",
+    "#a = 0; *b(){}",
+    "#a = 0; ['b'](){}",
+    "#a;",
+    "#a; #b;",
+    "#a; b(){}",
+    "#a; *b(){}",
+    "#a; ['b'](){}",
+
+    // ASI
+    "#a = 0\n",
+    "#a = 0\n #b",
+    "#a = 0\n b(){}",
+    "#a\n",
+    "#a\n #b\n",
+    "#a\n b(){}",
+    "#a\n *b(){}",
+    "#a\n ['b'](){}",
+
+    // Misc edge cases
+    "#yield",
+    "#yield = 0",
+    "#yield\n #a",
+    NULL
+  };
+  // clang-format on
+
+  static const ParserFlag flags[] = {kAllowHarmonyPrivateClassFields};
+  RunParserSyncTest(class_body_contexts, class_body_data, kSuccess, NULL, 0,
+                    flags, arraysize(flags));
+
+  // clang-format off
+  const char* declaration_contexts[][2] = {{"(class { #x;", "});"},
+                                           {"(class extends Base { #x;", "});"},
+                                           {"class C { #x;", "}"},
+                                           {"class C extends Base { #x;", "}"},
+                                           {"(class {", "\n#x;});"},
+                                           {NULL, NULL}};
+  const char* declaration_bodies[] = {
+    "m(){ ++#x; return #x; }",
+    "m(o){ ++#x; return o.#x; }",
+    "m(){ #x = 0; }",
+    "m(o){ o.#x = 0; }",
+    "m(){ ({a: #x} = {a: 0}); }",
+    "m(){ ({a: o.#x} = {a: 0}); }",
+    "static m(){ ++#x; return #x; }",
+    "static m(o){ ++#x; return o.#x; }",
+    "static m(){ #x = 0; }",
+    "static m(o){ o.#x = 0; }",
+    "static m(){ ({a: #x} = {a: 0}); }",
+    "static m(){ ({a: o.#x} = {a: 0}); }",
+    NULL
+  };
+  // clang-format on
+
+  RunParserSyncTest(declaration_contexts, declaration_bodies, kSuccess, NULL, 0,
+                    flags, arraysize(flags));
+}
+
+TEST(ClassPrivatesErrors) {
+  // clang-format off
+  // Tests proposed class private fields syntax.
+  const char* context_data[][2] = {{"(class {", "});"},
+                                   {"(class extends Base {", "});"},
+                                   {"class C {", "}"},
+                                   {"class C extends Base {", "}"},
+                                   {NULL, NULL}};
+  // clang-format off
+  const char* class_body_data[] = {
+    "#x = 0\n *a(){}",
+    "#['x'] = 0;",
+    "#['x'];",
+    "#x; #x;",
+    "#x = 0; #x;",
+    "#x = 0; #x = 0",
+    NULL
+  };
+  // clang-format on
+
+  static const ParserFlag without_async[] = {kAllowHarmonyPrivateClassFields};
+  RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
+                    without_async, arraysize(without_async));
+}
+
 TEST(ClassExpressionErrors) {
   const char* context_data[][2] = {{"(", ");"},
                                    {"var C = ", ";"},
                                    {"bar, ", ";"},
                                    {NULL, NULL}};
   const char* class_data[] = {
     "class",
     "class name",
     "class name extends",
     "class extends",
@@ skipping 3740 matching lines @@
     "(a,);",
     "(a,b,c,);",
     NULL
   };
   // clang-format on
 
   static const ParserFlag always_flags[] = {kAllowHarmonyTrailingCommas};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }