[strong] Implement static restrictions on switch statement

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/v8.h"
 
 #include "src/assembler.h"
@@ skipping 262 matching lines @@
   int position_;
 };
 
 
 class Statement : public AstNode {
  public:
   explicit Statement(Zone* zone, int position) : AstNode(position) {}
 
   bool IsEmpty() { return AsEmptyStatement() != NULL; }
   virtual bool IsJump() const { return false; }
+  virtual bool IsStrongSwitchTerminatingStatement() const { return false; }

[rossberg, 2015/04/14 20:19:49]

I'm tempted to get rid of this and just use IsJump. AFAICS the only remaining
difference is IfStatement. I'm willing to tweak the spec to cover that. Adapting
the preparser should be straightforward as well.

[conradw, 2015/04/15 11:40:03]

Done.

 };
 
 
 class SmallMapList FINAL {
  public:
   SmallMapList() {}
   SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
 
   void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
   void Clear() { list_.Clear(); }
@@ skipping 214 matching lines @@
   ZoneList<Statement*>* statements() { return &statements_; }
   bool is_initializer_block() const { return is_initializer_block_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 
   bool IsJump() const OVERRIDE {
     return !statements_.is_empty() && statements_.last()->IsJump()
         && labels() == NULL;  // Good enough as an approximation...
   }
+  bool IsStrongSwitchTerminatingStatement() const OVERRIDE {
+    return IsJump();
+  }
 
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
  protected:
   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
         bool is_initializer_block, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
         statements_(capacity, zone),
         is_initializer_block_(is_initializer_block),
@@ skipping 485 matching lines @@
 };
 
 
 class ExpressionStatement FINAL : public Statement {
  public:
   DECLARE_NODE_TYPE(ExpressionStatement)
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
   bool IsJump() const OVERRIDE { return expression_->IsThrow(); }
+  bool IsStrongSwitchTerminatingStatement() const OVERRIDE { return IsJump(); }
 
  protected:
   ExpressionStatement(Zone* zone, Expression* expression, int pos)
       : Statement(zone, pos), expression_(expression) { }
 
  private:
   Expression* expression_;
 };
 
 
 class JumpStatement : public Statement {
  public:
   bool IsJump() const FINAL { return true; }
+  bool IsStrongSwitchTerminatingStatement() const FINAL { return true; }
 
  protected:
   explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
 };
 
 
 class ContinueStatement FINAL : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(ContinueStatement)
 
@@ skipping 2532 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_