[es6] Correct parsing of regular expression literal flags.

src/ast.h

 // 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.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 1547 matching lines @@
   Zone* zone_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral final : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(RegExpLiteral)
 
   Handle<String> pattern() const { return pattern_->string(); }
-  Handle<String> flags() const { return flags_->string(); }
+  int flags() const { return flags_; }
 
  protected:
-  RegExpLiteral(Zone* zone, const AstRawString* pattern,
-                const AstRawString* flags, int literal_index, bool is_strong,
-                int pos)
+  RegExpLiteral(Zone* zone, const AstRawString* pattern, int flags,
+                int literal_index, bool is_strong, int pos)
       : MaterializedLiteral(zone, literal_index, is_strong, pos),
         pattern_(pattern),
         flags_(flags) {
     set_depth(1);
   }
 
  private:
-  const AstRawString* pattern_;
-  const AstRawString* flags_;
+  const AstRawString* const pattern_;
+  int const flags_;
 };
 
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
 class ArrayLiteral final : public MaterializedLiteral {
  public:
   DECLARE_NODE_TYPE(ArrayLiteral)
 
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
@@ skipping 1838 matching lines @@
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
                                                     Expression* value,
                                                     bool is_static,
                                                     bool is_computed_name) {
     return new (local_zone_) ObjectLiteral::Property(
         ast_value_factory_, key, value, is_static, is_computed_name);
   }
 
-  RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern,
-                                  const AstRawString* flags,
-                                  int literal_index,
-                                  bool is_strong,
-                                  int pos) {
+  RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern, int flags,
+                                  int literal_index, bool is_strong, int pos) {
     return new (local_zone_) RegExpLiteral(local_zone_, pattern, flags,
                                            literal_index, is_strong, pos);
   }
 
   ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
                                 int literal_index,
                                 bool is_strong,
                                 int pos) {
     return new (local_zone_)
         ArrayLiteral(local_zone_, values, -1, literal_index, is_strong, pos);
@@ skipping 214 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_