Implement iterator finalization in array destructuring.

src/parsing/parser.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_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 448 matching lines @@
   // Generate AST node that throws a TypeError with the given
   // type. Both arguments must be non-null (in the handle sense).
   Expression* NewThrowTypeError(MessageTemplate::Template message,
                                 const AstRawString* arg, int pos);
 
   // Generic AST generator for throwing errors from compiled code.
   Expression* NewThrowError(Runtime::FunctionId function_id,
                             MessageTemplate::Template message,
                             const AstRawString* arg, int pos);
 
+  void FinalizeIteratorUse(Variable* completion, Expression* condition,
+      Variable* iter, Block* iterator_use, Block* result);
+
   Statement* FinalizeForOfStatement(ForOfStatement* loop, int pos);
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location source_location,
                        MessageTemplate::Template message,
                        const char* arg = NULL,
                        ParseErrorType error_type = kSyntaxError);
   void ReportMessage(MessageTemplate::Template message, const char* arg = NULL,
                      ParseErrorType error_type = kSyntaxError);
   void ReportMessage(MessageTemplate::Template message, const AstRawString* arg,
@@ skipping 188 matching lines @@
   Expression* RewriteYieldStar(
       Expression* generator, Expression* expression, int pos);
 
   Expression* RewriteInstanceof(Expression* lhs, Expression* rhs, int pos);
 
  private:
   Parser* parser_;
 
   void BuildIteratorClose(ZoneList<Statement*>* statements, Variable* iterator,
                           Maybe<Variable*> input, Variable* output);
+
   void BuildIteratorCloseForCompletion(
       ZoneList<Statement*>* statements, Variable* iterator,
-      Variable* body_threw);
+      Variable* completion);
+
   Statement* CheckCallable(Variable* var, Expression* error);
 };
 
 
 class Parser : public ParserBase<ParserTraits> {
  public:
   explicit Parser(ParseInfo* info);
   ~Parser() {
     delete reusable_preparser_;
     reusable_preparser_ = NULL;
     delete cached_parse_data_;
     cached_parse_data_ = NULL;
   }
 
   // Parses the source code represented by the compilation info and sets its
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool ParseStatic(ParseInfo* info);
   bool Parse(ParseInfo* info);
   void ParseOnBackground(ParseInfo* info);
 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize(Isolate* isolate, Handle<Script> script, bool error);
   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
 
+  // Runtime encoding of different completion modes.
+  enum CompletionKind {

[adamk, 2016/03/07 20:28:05]

Can you make this an enum class? Otherwise you've effectively added a bunch of
bare names as valid identifiers in all 7000 lines of parser.cc.

[neis, 2016/03/08 13:40:10]

If I make it an enum class, then instead of eg NORMAL etc. I will have to write
static_cast<int>(CompletionKind::NORMAL).  So I prefer keeping it as is.  I made
it private, though (there was no reason for it to be public).

[adamk, 2016/03/08 18:41:13]

Oh, I forgot about that bit. The thing that bothers me is actually the
shortness, not the typing; "NORMAL" is an especially strange identifier to add
if it means something as specific as non-abrupt completion. How about:

kNormalCompletion
kThrowCompletion
kAbruptCompletion

"kThrowCompletion" is a little bit funny, but the others seem reasonable. WDYT?

+    NORMAL = 0,
+    THROW = 1,
+    BREAK = 2,
+    CONTINUE = 4,
+    RETURN = 8,
+    ABRUPT = THROW | BREAK | CONTINUE | RETURN

[adamk, 2016/03/07 20:28:05]

Besides this line, do you actually use this enum as a bit pattern? I didn't see
anyplace on first run through, which suggests to me that it shouldn't be one.

[neis, 2016/03/08 13:40:10]

Alright, changed it back to three values.

+  };
+
  private:
   friend class ParserTraits;
 
   // Limit the allowed number of local variables in a function. The hard limit
   // is that offsets computed by FullCodeGenerator::StackOperand and similar
   // functions are ints, and they should not overflow. In addition, accessing
   // local variables creates user-controlled constants in the generated code,
   // and we don't want too much user-controlled memory inside the code (this was
   // the reason why this limit was introduced in the first place; see
   // https://codereview.chromium.org/7003030/ ).
@@ skipping 194 matching lines @@
   CaseClause* ParseCaseClause(bool* default_seen_ptr, bool* ok);
   Statement* ParseSwitchStatement(ZoneList<const AstRawString*>* labels,
                                   bool* ok);
   DoWhileStatement* ParseDoWhileStatement(ZoneList<const AstRawString*>* labels,
                                           bool* ok);
   WhileStatement* ParseWhileStatement(ZoneList<const AstRawString*>* labels,
                                       bool* ok);
   Statement* ParseForStatement(ZoneList<const AstRawString*>* labels, bool* ok);
   Statement* ParseThrowStatement(bool* ok);
   Expression* MakeCatchContext(Handle<String> id, VariableProxy* value);
+
   class DontCollectExpressionsInTailPositionScope;
   class CollectExpressionsInTailPositionToListScope;
   TryStatement* ParseTryStatement(bool* ok);
   DebuggerStatement* ParseDebuggerStatement(bool* ok);
   // Parse a SubStatement in strict mode, or with an extra block scope in
   // sloppy mode to handle
   // ES#sec-functiondeclarations-in-ifstatement-statement-clauses
   // The legacy parameter indicates whether function declarations are
   // banned by the ES2015 specification in this location, and they are being
   // permitted here to match previous V8 behavior.
@@ skipping 308 matching lines @@
 
 DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
   return parser_->ParseDoExpression(ok);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_