[regexp] Experimental support for regexp named captures

src/regexp/regexp-ast.h

 // Copyright 2016 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.
 
 #ifndef V8_REGEXP_REGEXP_AST_H_
 #define V8_REGEXP_REGEXP_AST_H_
 
 #include "src/objects.h"
 #include "src/utils.h"
 #include "src/zone.h"
@@ skipping 409 matching lines @@
   RegExpCapture* AsCapture() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   Interval CaptureRegisters() override;
   bool IsCapture() override;
   int min_match() override { return body_->min_match(); }
   int max_match() override { return body_->max_match(); }
   RegExpTree* body() { return body_; }
   void set_body(RegExpTree* body) { body_ = body; }
   int index() { return index_; }
+  Vector<const uc16> name() const { return name_; }
+  void set_name(Vector<const uc16> name) { name_ = name; }
   static int StartRegister(int index) { return index * 2; }
   static int EndRegister(int index) { return index * 2 + 1; }
 
  private:
   RegExpTree* body_;
   int index_;
+  Vector<const uc16> name_;
 };
 
 
 class RegExpLookaround final : public RegExpTree {
  public:
   enum Type { LOOKAHEAD, LOOKBEHIND };
 
   RegExpLookaround(RegExpTree* body, bool is_positive, int capture_count,
                    int capture_from, Type type)
       : body_(body),
@@ skipping 36 matching lines @@
   RegExpTree* body_;
   bool is_positive_;
   int capture_count_;
   int capture_from_;
   Type type_;
 };
 
 
 class RegExpBackReference final : public RegExpTree {
  public:
+  RegExpBackReference() : capture_(nullptr) {}
   explicit RegExpBackReference(RegExpCapture* capture) : capture_(capture) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpBackReference* AsBackReference() override;
   bool IsBackReference() override;
   int min_match() override { return 0; }
   // The back reference may be recursive, e.g. /(\2)(\1)/. To avoid infinite
   // recursion, we give up. Ignorance is bliss.
   int max_match() override { return kInfinity; }
   int index() { return capture_->index(); }
   RegExpCapture* capture() { return capture_; }
+  void set_capture(RegExpCapture* capture) { capture_ = capture; }
+  Vector<const uc16> name() const { return name_; }
+  void set_name(Vector<const uc16> name) { name_ = name; }
 
  private:
   RegExpCapture* capture_;
+  Vector<const uc16> name_;
 };
 
 
 class RegExpEmpty final : public RegExpTree {
  public:
   RegExpEmpty() {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpEmpty* AsEmpty() override;
   bool IsEmpty() override;
   int min_match() override { return 0; }
   int max_match() override { return 0; }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGEXP_REGEXP_AST_H_