[coverage] Block coverage with support for IfStatements

src/ast/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_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 164 matching lines @@
   FeedbackVectorSpec* get_spec() { return &spec_; }
 
  private:
   Flags flags_;
   int node_count_;
   FeedbackVectorSpec spec_;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
 
+struct SourceRange {
+  SourceRange() : from(kNoSourcePosition), to(kNoSourcePosition) {}
+  int32_t from, to;

[marja, 2017/05/18 11:30:17]

In Scope, FunctionLiteral etc. there's already start_position and end_position,
I think it makes sense to have consistent naming there. I.e., these should be
start_position and end_position instead of from and to.

[jgruber, 2017/05/22 09:43:32]

No very strong feelings on this from my side, but if possible I'd prefer keeping
the names short. What about {start, end}?

Maybe we could also change Scope, FunctionLiteral etc. to contain a SourceRange
at some point.

[marja, 2017/05/22 12:55:37]

start + end sgtm

+};
 
 class AstNode: public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum NodeType : uint8_t { AST_NODE_LIST(DECLARE_TYPE_ENUM) };
 #undef DECLARE_TYPE_ENUM
 
   void* operator new(size_t size, Zone* zone) { return zone->New(size); }
 
   NodeType node_type() const { return NodeTypeField::decode(bit_field_); }
@@ skipping 813 matching lines @@
 // given if-statement has a then- or an else-part containing code.
 class IfStatement final : public Statement {
  public:
   bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
   bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
 
   Expression* condition() const { return condition_; }
   Statement* then_statement() const { return then_statement_; }
   Statement* else_statement() const { return else_statement_; }
 
+  SourceRange then_range() const { return then_range_; }
+  SourceRange else_range() const { return else_range_; }
+
   void set_condition(Expression* e) { condition_ = e; }
   void set_then_statement(Statement* s) { then_statement_ = s; }
   void set_else_statement(Statement* s) { else_statement_ = s; }
 
   bool IsJump() const {
     return HasThenStatement() && then_statement()->IsJump()
         && HasElseStatement() && else_statement()->IsJump();
   }
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 3; }
   BailoutId IfId() const { return BailoutId(local_id(0)); }
   BailoutId ThenId() const { return BailoutId(local_id(1)); }
   BailoutId ElseId() const { return BailoutId(local_id(2)); }
 
  private:
   friend class AstNodeFactory;
 
   IfStatement(Expression* condition, Statement* then_statement,
-              Statement* else_statement, int pos)
+              Statement* else_statement, int pos, SourceRange then_range,
+              SourceRange else_range)
       : Statement(pos, kIfStatement),
         base_id_(BailoutId::None().ToInt()),
         condition_(condition),
         then_statement_(then_statement),
-        else_statement_(else_statement) {}
+        else_statement_(else_statement),
+        then_range_(then_range),
+        else_range_(else_range) {}
 
   static int parent_num_ids() { return 0; }
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int base_id_;
   Expression* condition_;
   Statement* then_statement_;
   Statement* else_statement_;
+  SourceRange then_range_;
+  SourceRange else_range_;
 };
 
 
 class TryStatement : public Statement {
  public:
   Block* try_block() const { return try_block_; }
   void set_try_block(Block* b) { try_block_ = b; }
 
   // Prediction of whether exceptions thrown into the handler for this try block
   // will be caught.
@@ skipping 2270 matching lines @@
         ReturnStatement(expression, ReturnStatement::kAsyncReturn, pos);
   }
 
   WithStatement* NewWithStatement(Scope* scope,
                                   Expression* expression,
                                   Statement* statement,
                                   int pos) {
     return new (zone_) WithStatement(scope, expression, statement, pos);
   }
 
-  IfStatement* NewIfStatement(Expression* condition,
-                              Statement* then_statement,
-                              Statement* else_statement,
-                              int pos) {
-    return new (zone_)
-        IfStatement(condition, then_statement, else_statement, pos);
+  IfStatement* NewIfStatement(Expression* condition, Statement* then_statement,
+                              Statement* else_statement, int pos,
+                              SourceRange then_range = {},
+                              SourceRange else_range = {}) {
+    return new (zone_) IfStatement(condition, then_statement, else_statement,
+                                   pos, then_range, else_range);
   }
 
   TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
                                           Block* catch_block, int pos) {
     return new (zone_) TryCatchStatement(try_block, scope, catch_block,
                                          HandlerTable::CAUGHT, pos);
   }
 
   TryCatchStatement* NewTryCatchStatementForReThrow(Block* try_block,
                                                     Scope* scope,
@@ skipping 394 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_