Devirtualize AstNode and subclasses, except for visiting-related methods.

src/ast/ast.cc

 // 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.
 
 #include "src/ast/ast.h"
 
 #include <cmath>  // For isfinite.
 
 #include "src/ast/prettyprinter.h"
 #include "src/ast/scopes.h"
@@ skipping 29 matching lines @@
   AstPrinter::PrintOut(isolate, this);
 }
 
 
 void AstNode::PrettyPrint(Isolate* isolate) {
   PrettyPrinter::PrintOut(isolate, this);
 }
 
 #endif  // DEBUG
 
+#define RETURN_NODE(Node) \
+  case k##Node:           \
+    return static_cast<Node*>(this);
+
+IterationStatement* AstNode::AsIterationStatement() {
+  switch (node_type()) {
+    ITERATION_NODE_LIST(RETURN_NODE);
+    default:
+      return nullptr;
+  }
+}
+
+BreakableStatement* AstNode::AsBreakableStatement() {
+  switch (node_type()) {
+    BREAKABLE_NODE_LIST(RETURN_NODE);
+    ITERATION_NODE_LIST(RETURN_NODE);
+    default:
+      return nullptr;
+  }
+}
+
+MaterializedLiteral* AstNode::AsMaterializedLiteral() {
+  switch (node_type()) {
+    LITERAL_NODE_LIST(RETURN_NODE);
+    default:
+      return nullptr;
+  }
+}
+
+#undef RETURN_NODE
+
+InitializationFlag Declaration::initialization() const {
+  switch (node_type()) {
+#define GENERATE_CASE(Node) \
+  case k##Node:             \

[Igor Sheludko, 2016/07/14 14:02:33]

How about adding something like 
  STATIC_ASSERT(&Expression::initialization != &Node::initialization);
here and in similar places below to avoid accidental infinite recursion.

[Toon Verwaest, 2016/07/14 14:19:39]

I'd add STATIC_ASSERT(k##Node != kExpression), however, only leaf-classes are in
NodeType. Which also means that it's impossible to get Expression in here ... Do
you really want me to add it? :)

[Igor Sheludko, 2016/07/14 14:49:30]

No, the idea is to ensure that when you call a foo() via static_cast<const
Node*>(this)->foo() you will not actually call the dispatcher foo() again.

+    return static_cast<const Node*>(this)->initialization();
+    DECLARATION_NODE_LIST(GENERATE_CASE);
+#undef GENERATE_CASE
+    default:
+      UNREACHABLE();
+      return kNeedsInitialization;
+  }
+}
 
 bool Expression::IsSmiLiteral() const {
   return IsLiteral() && AsLiteral()->value()->IsSmi();
 }
 
 
 bool Expression::IsStringLiteral() const {
   return IsLiteral() && AsLiteral()->value()->IsString();
 }
 
+bool Expression::IsPropertyName() const {
+  return IsLiteral() && AsLiteral()->IsPropertyName();
+}
 
 bool Expression::IsNullLiteral() const {
   if (!IsLiteral()) return false;
   Handle<Object> value = AsLiteral()->value();
   return !value->IsSmi() &&
          value->IsNull(HeapObject::cast(*value)->GetIsolate());
 }
 
 bool Expression::IsUndefinedLiteral() const {
   if (IsLiteral()) {
     Handle<Object> value = AsLiteral()->value();
     if (!value->IsSmi() &&
         value->IsUndefined(HeapObject::cast(*value)->GetIsolate())) {
       return true;
     }
   }
 
   const VariableProxy* var_proxy = AsVariableProxy();
   if (var_proxy == NULL) return false;
   Variable* var = var_proxy->var();
   // The global identifier "undefined" is immutable. Everything
   // else could be reassigned.
   return var != NULL && var->IsUnallocatedOrGlobalSlot() &&
          var_proxy->raw_name()->IsOneByteEqualTo("undefined");
 }
 
+bool Expression::ToBooleanIsTrue() const {
+  return IsLiteral() && AsLiteral()->ToBooleanIsTrue();
+}
+
+bool Expression::ToBooleanIsFalse() const {
+  return IsLiteral() && AsLiteral()->ToBooleanIsFalse();
+}
+
+bool Expression::IsValidReferenceExpression() const {
+  return IsProperty() ||
+         (IsVariableProxy() && AsVariableProxy()->IsValidReferenceExpression());
+}
 
 bool Expression::IsValidReferenceExpressionOrThis() const {
   return IsValidReferenceExpression() ||
          (IsVariableProxy() && AsVariableProxy()->is_this());
 }
 
+bool Expression::IsAnonymousFunctionDefinition() const {
+  return (IsFunctionLiteral() &&
+          AsFunctionLiteral()->IsAnonymousFunctionDefinition()) ||
+         (IsClassLiteral() &&
+          AsClassLiteral()->IsAnonymousFunctionDefinition());
+}
+
+void Expression::MarkTail() {
+  if (IsConditional()) {
+    AsConditional()->MarkTail();
+  } else if (IsCall()) {
+    AsCall()->MarkTail();
+  } else if (IsBinaryOperation()) {
+    AsBinaryOperation()->MarkTail();
+  }
+}
+
+bool Statement::IsJump() const {
+  return (IsBlock() && AsBlock()->IsJump()) ||
+         (IsExpressionStatement() && AsExpressionStatement()->IsJump()) ||
+         IsContinueStatement() || IsBreakStatement() || IsReturnStatement() ||

[Igor Sheludko, 2016/07/14 14:02:33]

How about following same pattern for all JumpStatements:
  IsContinueStatement() && AsContinueStatement()->IsJump()?
otherwise JumpStatements::IsJump() is going to be unused and could eventually
went out of sync with this method.

Maybe it is even better to rewrite this whole method the same way you rewrote
IsMonomorphic() dispatcher (with switch and casts).

[Toon Verwaest, 2016/07/14 14:19:39]

Done.

+         (IsIfStatement() && AsIfStatement()->IsJump());
+}
 
 VariableProxy::VariableProxy(Zone* zone, Variable* var, int start_position,
                              int end_position)
     : Expression(zone, start_position),
       bit_field_(IsThisField::encode(var->is_this()) |
                  IsAssignedField::encode(false) |
                  IsResolvedField::encode(false)),
       raw_name_(var->raw_name()),
       end_position_(end_position) {
   BindTo(var);
@@ skipping 610 matching lines @@
 }
 
 
 // ----------------------------------------------------------------------------
 // Recording of type feedback
 
 // TODO(rossberg): all RecordTypeFeedback functions should disappear
 // once we use the common type field in the AST consistently.
 
 void Expression::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
-  set_to_boolean_types(oracle->ToBooleanTypes(test_id()));
+  if (IsUnaryOperation()) {
+    AsUnaryOperation()->RecordToBooleanTypeFeedback(oracle);
+  } else if (IsBinaryOperation()) {
+    AsBinaryOperation()->RecordToBooleanTypeFeedback(oracle);
+  } else {
+    set_to_boolean_types(oracle->ToBooleanTypes(test_id()));
+  }
 }
 
+SmallMapList* Expression::GetReceiverTypes() {
+  switch (node_type()) {
+#define NODE_LIST(V)    \
+  PROPERTY_NODE_LIST(V) \
+  V(Call)
+#define GENERATE_CASE(Node) \
+  case k##Node:             \
+    return static_cast<Node*>(this)->GetReceiverTypes();
+    NODE_LIST(GENERATE_CASE)
+#undef NODE_LIST
+#undef GENERATE_CASE
+    default:
+      UNREACHABLE();
+      return nullptr;
+  }
+}
+
+KeyedAccessStoreMode Expression::GetStoreMode() const {
+  switch (node_type()) {
+#define GENERATE_CASE(Node) \
+  case k##Node:             \
+    return static_cast<const Node*>(this)->GetStoreMode();
+    PROPERTY_NODE_LIST(GENERATE_CASE)
+#undef GENERATE_CASE
+    default:
+      UNREACHABLE();
+      return STANDARD_STORE;
+  }
+}
+
+IcCheckType Expression::GetKeyType() const {
+  switch (node_type()) {
+#define GENERATE_CASE(Node) \
+  case k##Node:             \
+    return static_cast<const Node*>(this)->GetKeyType();
+    PROPERTY_NODE_LIST(GENERATE_CASE)
+#undef GENERATE_CASE
+    default:
+      UNREACHABLE();
+      return PROPERTY;
+  }
+}
+
+bool Expression::IsMonomorphic() const {
+  switch (node_type()) {
+#define GENERATE_CASE(Node) \
+  case k##Node:             \
+    return static_cast<const Node*>(this)->IsMonomorphic();
+    PROPERTY_NODE_LIST(GENERATE_CASE)
+    CALL_NODE_LIST(GENERATE_CASE)

[Igor Sheludko, 2016/07/14 14:02:33]

GENERATE_CASE(ObjectLiteralProperty) ?

[Toon Verwaest, 2016/07/14 14:19:39]

ObjectLiteralProperty is not an AstNode. It derives directly from ZoneObject.
Hence its IsMonomorphic doesn't overlap.

[Igor Sheludko, 2016/07/14 14:49:30]

Ah, indeed.

+#undef GENERATE_CASE
+    default:
+      UNREACHABLE();
+      return false;
+  }
+}
 
 bool Call::IsUsingCallFeedbackICSlot(Isolate* isolate) const {
   CallType call_type = GetCallType(isolate);
   if (call_type == POSSIBLY_EVAL_CALL) {
     return false;
   }
   return true;
 }
 
 
@@ skipping 392 matching lines @@
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 
 }  // namespace internal
 }  // namespace v8