Private fields

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 152 matching lines @@
   VariableProxy* init_fn_proxy = scope->NewUnresolved(factory(), init_fn_name);
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(init_fn_proxy, zone());
   args->Add(this_expr, zone());
   return factory()->NewCallRuntime(Runtime::kInlineCall, args,
                                    kNoSourcePosition);
 }
 
 Expression* Parser::RewriteSuperCall(Expression* super_call) {
   // TODO(bakkot) find a way to avoid this for classes without fields.
-  if (!allow_harmony_class_fields()) {
+  if (!(allow_harmony_class_fields() || allow_harmony_private_class_fields())) {
     return super_call;
   }
   // This turns a super call `super()` into a do expression of the form
   // do {
   //   tmp x = super();
   //   if (.class-field-init)
   //     .class-field-init(x)
   //   x; // This isn't actually present; our do-expression representation
   // allows specifying that the expression returns x directly.
   // }
@@ skipping 405 matching lines @@
                       info->isolate()->is_tail_call_elimination_enabled());
   set_allow_harmony_do_expressions(FLAG_harmony_do_expressions);
   set_allow_harmony_for_in(FLAG_harmony_for_in);
   set_allow_harmony_function_sent(FLAG_harmony_function_sent);
   set_allow_harmony_restrictive_declarations(
       FLAG_harmony_restrictive_declarations);
   set_allow_harmony_async_await(FLAG_harmony_async_await);
   set_allow_harmony_restrictive_generators(FLAG_harmony_restrictive_generators);
   set_allow_harmony_trailing_commas(FLAG_harmony_trailing_commas);
   set_allow_harmony_class_fields(FLAG_harmony_class_fields);
+  set_allow_harmony_private_class_fields(FLAG_harmony_private_class_fields);
   for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
        ++feature) {
     use_counts_[feature] = 0;
   }
   if (info->ast_value_factory() == NULL) {
     // info takes ownership of AstValueFactory.
     info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed()));
     info->set_ast_value_factory_owned();
     ast_value_factory_ = info->ast_value_factory();
     ast_node_factory_.set_ast_value_factory(ast_value_factory_);
@@ skipping 2761 matching lines @@
   Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
   Block* block = ParseBlock(nullptr, CHECK_OK);
   DoExpression* expr = factory()->NewDoExpression(block, result, pos);
   if (!Rewriter::Rewrite(this, GetClosureScope(), expr, ast_value_factory())) {
     *ok = false;
     return nullptr;
   }
   return expr;
 }
 
+const AstRawString* ClassPrivateFieldVariableName(
+    AstValueFactory* ast_value_factory, const AstRawString* raw_name) {
+  // Prepends '#'
+  return ast_value_factory->ConcatStrings(
+      ast_value_factory->number_sign_string(), raw_name);
+}
+
+Property* Parser::ParsePrivateFieldReference(Expression* base, bool* ok) {
+  // PrimaryExpression ::
+  //     PrivateName
+
+  // This desugars a private field reference like `#a` or `obj.#a` into
+  // %ThrowIfMissingPrivateField(obj, #a)[#a]
+  // Here #a is a variable which will resolve to a private symbol when inside of
+  // a class which defines a private field named #a (otherwise attempting to
+  // resolve it will throw a reference error).
+
+  int pos = peek_position();
+
+  Expect(Token::HASH, CHECK_OK);
+  const AstRawString* property_name =
+      ParseIdentifierName(CHECK_OK);  // TODO(bakkot) more complex names
+  const AstRawString* symbol_var_name =
+      ClassPrivateFieldVariableName(ast_value_factory(), property_name);
+
+  ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
+  args->Add(base, zone());
+  args->Add(NewUnresolved(symbol_var_name), zone());
+  Expression* call = factory()->NewCallRuntime(
+      Runtime::kThrowIfMissingPrivateField, args, pos);
+  // TODO(bakkot) ideally we'd avoid this runtime function, either by adding a
+  // flag to the load/store IC or by adding a code stub for it. Currently it
+  // means that every private field access requires this runtime call, which is
+  // a slowdown we'd prefer to avoid.
+
+  Expression* prop = NewUnresolved(symbol_var_name);
+  return factory()->NewProperty(call, prop, pos);
+}
+
 void Parser::ParseArrowFunctionFormalParameterList(
     ParserFormalParameters* parameters, Expression* expr,
     const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
     const Scope::Snapshot& scope_snapshot, bool* ok) {
   if (expr->IsEmptyParentheses()) return;
 
   ParseArrowFunctionFormalParameters(parameters, expr, params_loc.end_pos,
                                      CHECK_OK_VOID);
 
   scope_snapshot.Reparent(parameters->scope);
@@ skipping 859 matching lines @@
     reusable_preparser_->set_allow_lazy(true);
 #define SET_ALLOW(name) reusable_preparser_->set_allow_##name(allow_##name());
     SET_ALLOW(natives);
     SET_ALLOW(harmony_do_expressions);
     SET_ALLOW(harmony_for_in);
     SET_ALLOW(harmony_function_sent);
     SET_ALLOW(harmony_restrictive_declarations);
     SET_ALLOW(harmony_async_await);
     SET_ALLOW(harmony_trailing_commas);
     SET_ALLOW(harmony_class_fields);
+    SET_ALLOW(harmony_private_class_fields);
 #undef SET_ALLOW
   }
   PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
       language_mode(), function_state_->kind(),
       scope()->AsDeclarationScope()->has_simple_parameters(), parsing_module_,
       logger, may_abort, use_counts_);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
@@ skipping 165 matching lines @@
     impl()->AccumulateFormalParameterContainmentErrors();
   } else {
     block_state.set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
   ZoneList<ClassLiteral::Property*>* properties = NewClassPropertyList(4);
   ZoneList<Expression*>* instance_field_initializers =
       new (zone()) ZoneList<Expression*>(0, zone());
+  ZoneList<Variable*>* private_field_symbol_vars =
+      new (zone()) ZoneList<Variable*>(0, zone());
+  ZoneList<Variable*>* private_field_index_vars =
+      new (zone()) ZoneList<Variable*>(0, zone());
   FunctionLiteral* constructor = nullptr;
   bool has_seen_constructor = false;
   Variable* static_initializer_var = nullptr;
 
   Block* do_block = factory()->NewBlock(nullptr, 1, false, pos);
   Variable* result_var = NewTemporary(ast_value_factory()->empty_string());
   DoExpression* do_expr = factory()->NewDoExpression(do_block, result_var, pos);
 
   Expect(Token::LBRACE, CHECK_OK);
 
   const bool has_extends = extends != nullptr;
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
+    const AstRawString* private_name = nullptr;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier property_classifier(this);
-    ClassLiteral::Property* property =
-        ParseClassPropertyDefinition(&checker, has_extends, &is_computed_name,
-                                     &has_seen_constructor, CHECK_OK);
+    ClassLiteral::Property* property = ParseClassPropertyDefinition(
+        &checker, has_extends, &private_name, &is_computed_name,
+        &has_seen_constructor, CHECK_OK);
     RewriteNonPattern(CHECK_OK);
     impl()->AccumulateFormalParameterContainmentErrors();
 
     if (has_seen_constructor && constructor == nullptr) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
       constructor->set_raw_name(
           name != nullptr ? name : ast_value_factory()->empty_string());
     } else {
       if (property->kind() == ClassLiteralProperty::FIELD) {
-        DCHECK(allow_harmony_class_fields());
-        if (property->is_static()) {
+        if (private_name != nullptr) {
+          DCHECK(allow_harmony_private_class_fields());
+          DCHECK(property->key() == nullptr);
+          DCHECK(!property->is_static());
+
+          const AstRawString* symbol_var_name =
+              ClassPrivateFieldVariableName(ast_value_factory(), private_name);
+          VariableProxy* symbol_var_proxy = NewUnresolved(symbol_var_name);
+          Declaration* symbol_var_declaration =
+              factory()->NewVariableDeclaration(symbol_var_proxy, scope(),
+                                                kNoSourcePosition);
+          Variable* symbol_var =
+              Declare(symbol_var_declaration, DeclarationDescriptor::NORMAL,
+                      CONST, kCreatedInitialized, ok, scope());
+          private_field_symbol_vars->Add(symbol_var, zone());
+
+          const AstRawString* index_var_name = ClassFieldVariableName(
+              true, ast_value_factory(), instance_field_initializers->length());
+          VariableProxy* index_var_proxy = NewUnresolved(index_var_name);
+          Declaration* index_var_declaration =
+              factory()->NewVariableDeclaration(index_var_proxy, scope(),
+                                                kNoSourcePosition);
+          Variable* index_var =
+              Declare(index_var_declaration, DeclarationDescriptor::NORMAL,
+                      CONST, kCreatedInitialized, ok, scope());
+          private_field_index_vars->Add(index_var, zone());
+
+          instance_field_initializers->Add(property->value(), zone());
+
+          // Does not add to properties because no action is required from the
+          // backend during class definition.
+        } else if (property->is_static()) {
+          DCHECK(allow_harmony_class_fields());
           if (static_initializer_var == nullptr) {
             static_initializer_var =
                 NewTemporary(ast_value_factory()->empty_string());
           }
           // TODO(bakkot) only do this conditionally
           Expression* function = InstallHomeObject(
               property->value(),
               factory()->NewVariableProxy(static_initializer_var));
           ZoneList<Expression*>* args =
               new (zone()) ZoneList<Expression*>(2, zone());
           args->Add(function, zone());
           args->Add(factory()->NewVariableProxy(static_initializer_var),
                     zone());
           Expression* call = factory()->NewCallRuntime(Runtime::kInlineCall,
                                                        args, kNoSourcePosition);
           property->set_value(call);
+          properties->Add(property, zone());
         } else {
+          DCHECK(allow_harmony_class_fields());
           // if (is_computed_name) { // TODO(bakkot) figure out why this is
           // necessary for non-computed names in full-codegen
           ZoneList<Expression*>* to_name_args =
               new (zone()) ZoneList<Expression*>(1, zone());
           to_name_args->Add(property->key(), zone());
           property->set_key(factory()->NewCallRuntime(
               Runtime::kToName, to_name_args, kNoSourcePosition));
           //}
           const AstRawString* name = ClassFieldVariableName(
               true, ast_value_factory(), instance_field_initializers->length());
           VariableProxy* name_proxy = NewUnresolved(name);
           Declaration* name_declaration = factory()->NewVariableDeclaration(
               name_proxy, scope(), kNoSourcePosition);
           Variable* name_var =
               Declare(name_declaration, DeclarationDescriptor::NORMAL, CONST,
                       kNeedsInitialization, ok, scope());
           DCHECK(ok);
           if (!ok) return nullptr;
           instance_field_initializers->Add(property->value(), zone());
           property->set_value(factory()->NewVariableProxy(name_var));
+          properties->Add(property, zone());
         }
+      } else {
+        properties->Add(property, zone());
       }
-      properties->Add(property, zone());
     }
 
     DCHECK_NOT_NULL(fni_);
     fni_->Infer();
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   int end_pos = scanner()->location().end_pos;
 
   bool has_instance_fields = instance_field_initializers->length() > 0;
-  DCHECK(!has_instance_fields || allow_harmony_class_fields());
+  DCHECK(!has_instance_fields || allow_harmony_class_fields() ||
+         allow_harmony_private_class_fields());
   bool has_default_constructor = constructor == nullptr;
   if (has_default_constructor) {
     constructor = DefaultConstructor(name, has_extends, has_instance_fields,
                                      pos, end_pos, block_state.language_mode());
   }
 
   if (has_instance_fields && extends == nullptr) {
     constructor = InsertClassFieldInitializer(constructor);
     constructor->set_requires_class_field_init(true);
   }  // The derived case is handled by rewriting super calls.
 
   block_state.set_end_position(end_pos);
 
   if (name != nullptr) {
     DCHECK_NOT_NULL(proxy);
     proxy->var()->set_initializer_position(end_pos);
   }
 
+  // The parser creates two variables for every private field, both of which
+  // store the private symbol which serves as the key for that field. One of
+  // them, 'symbol_var', is used when referencing private fields with '#a' in
+  // normal code. The other, 'index_var', is used when initializing the field.
+  // The later variable is necessary because the synthetic field initialization
+  // function has available to it *only* the number of fields in the class.
+  // The desugaring looks something like this:
+  //
+  // class C {
+  //   #foo = 0;
+  //   baz;
+  //   m(){
+  //    this.#bar = 'a';
+  //    #foo = 1;
+  //   }
+  //   #bar;
+  // }
+  // -- becomes --
+  // do {
+  //   class C {
+  //     m(){
+  //      %ThrowIfMissingPrivateField(this, .bar-symbol)[.bar-symbol] = 'a';
+  //      %ThrowIfMissingPrivateField(this, .foo-symbol)[.foo-symbol] = 1;
+  //     }
+  //     constructor(){
+  //       .initialize.call(this);
+  //     }
+  //   }
+  //
+  //   let .foo-symbol, .name-0, .init-0;
+  //   .foo-symbol = .name-0 = PrivateSymbol();
+  //   .init-0 = ()=>0;
+  //
+  //   let .name-1, .init-1;
+  //   // .name-1 is given value 'baz' by the backends during class definition
+  //   .init-1 = ()=>undefined;
+  //
+  //   let .bar-symbol, .name-2, .init-2;
+  //   .bar-symbol = .name-2 = PrivateSymbol();
+  //   .init-2 = ()=>undefined;
+  //
+  //   .initialize() {
+  //     this[.name-0] = .init-0(); // Actually this is defineOwnProperty not =
+  //     this[.name-1] = .init-1();
+  //     this[.name-2] = .init-2();
+  //   }
+  //
+  //   C;
+  // }
+  DCHECK(private_field_symbol_vars->length() ==
+         private_field_index_vars->length());
+  DCHECK(allow_harmony_private_class_fields() ||
+         private_field_symbol_vars->length() == 0);
+  for (int i = 0; i < private_field_symbol_vars->length(); ++i) {
+    VariableProxy* symbol_var_proxy =
+        factory()->NewVariableProxy(private_field_symbol_vars->at(i));
+    VariableProxy* index_var_proxy =
+        factory()->NewVariableProxy(private_field_index_vars->at(i));
+
+    ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
+    args->Add(factory()->NewUndefinedLiteral(kNoSourcePosition), zone());
+    Expression* name =
+        factory()->NewCallRuntime(Runtime::kCreatePrivateSymbol, args, pos);
+
+    Assignment* inner_assignment = factory()->NewAssignment(
+        Token::INIT, index_var_proxy, name, kNoSourcePosition);
+    Assignment* outer_assignment = factory()->NewAssignment(
+        Token::INIT, symbol_var_proxy, inner_assignment, kNoSourcePosition);
+    do_block->statements()->Add(
+        factory()->NewExpressionStatement(outer_assignment, kNoSourcePosition),
+        zone());
+  }
+
   ClassLiteral* class_literal = factory()->NewClassLiteral(
       proxy, extends, constructor, properties, pos, end_pos);
 
   if (static_initializer_var != nullptr) {
     class_literal->set_static_initializer_proxy(
         factory()->NewVariableProxy(static_initializer_var));
   }
 
   do_block->statements()->Add(
       factory()->NewExpressionStatement(
           factory()->NewAssignment(Token::ASSIGN,
                                    factory()->NewVariableProxy(result_var),
                                    class_literal, kNoSourcePosition),
           pos),
       zone());
-  if (allow_harmony_class_fields() &&
+  if ((allow_harmony_class_fields() || allow_harmony_private_class_fields()) &&
       (has_instance_fields ||
        (extends != nullptr && !has_default_constructor))) {
     // Default constructors for derived classes without fields will not try to
     // read this variable, so there's no need to create it.
     const AstRawString* init_fn_name =
         ast_value_factory()->dot_class_field_init_string();
     Variable* init_fn_var = scope()->DeclareLocal(
         init_fn_name, CONST, kCreatedInitialized, NORMAL_VARIABLE);
     Expression* initializer =
         has_instance_fields
@@ skipping 1920 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8