[type-profile] Handle returns correctly.

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 886 matching lines @@
 
 class ReturnStatement final : public JumpStatement {
  public:
   enum Type { kNormal, kAsyncReturn };
   Expression* expression() const { return expression_; }
 
   void set_expression(Expression* e) { expression_ = e; }
   Type type() const { return TypeField::decode(bit_field_); }
   bool is_async_return() const { return type() == kAsyncReturn; }
 
-  FeedbackSlot TypeProfileSlot() const {
-    DCHECK(HasTypeProfileSlot());
-    return type_profile_slot_;
-  }
-
-  void SetTypeProfileSlot(FeedbackSlot slot) { type_profile_slot_ = slot; }
-
-  bool HasTypeProfileSlot() const { return !type_profile_slot_.IsInvalid(); }
-
  private:
   friend class AstNodeFactory;
 
   ReturnStatement(Expression* expression, Type type, int pos)
       : JumpStatement(pos, kReturnStatement), expression_(expression) {
     bit_field_ |= TypeField::encode(type);
   }
 
-  FeedbackSlot type_profile_slot_;
-
   Expression* expression_;
 
   class TypeField
       : public BitField<Type, JumpStatement::kNextBitFieldIndex, 1> {};
 };
 
 
 class WithStatement final : public Statement {
  public:
   Scope* scope() { return scope_; }
@@ skipping 1482 matching lines @@
     bit_field_ = IsUninitializedField::update(bit_field_, b);
   }
   void set_key_type(IcCheckType key_type) {
     bit_field_ = KeyTypeField::update(bit_field_, key_type);
   }
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
   }
 
   void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
-                           FeedbackSlotCache* cache,
-                           bool collect_type_profile = false);
+                           FeedbackSlotCache* cache);
   FeedbackSlot AssignmentSlot() const { return slot_; }
 
-  FeedbackSlot TypeProfileSlot() const {
-    DCHECK(HasTypeProfileSlot());
-    return type_profile_slot_;
-  }
-
-  bool HasTypeProfileSlot() const { return !type_profile_slot_.IsInvalid(); }
-
  private:
   friend class AstNodeFactory;
 
   Assignment(Token::Value op, Expression* target, Expression* value, int pos);
 
   static int parent_num_ids() { return Expression::num_ids(); }
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsUninitializedField
       : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
   class KeyTypeField
       : public BitField<IcCheckType, IsUninitializedField::kNext, 1> {};
   class StoreModeField
       : public BitField<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
   class TokenField : public BitField<Token::Value, StoreModeField::kNext, 7> {};
 
   FeedbackSlot slot_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   SmallMapList receiver_types_;
-
-  FeedbackSlot type_profile_slot_;
 };
 
 
 // The RewritableExpression class is a wrapper for AST nodes that wait
 // for some potential rewriting.  However, even if such nodes are indeed
 // rewritten, the RewritableExpression wrapper nodes will survive in the
 // final AST and should be just ignored, i.e., they should be treated as
 // equivalent to the wrapped nodes.  For this reason and to simplify later
 // phases, RewritableExpressions are considered as exceptions of AST nodes
 // in the following sense:
@@ skipping 127 matching lines @@
   bool is_anonymous_expression() const {
     return function_type() == kAnonymousExpression;
   }
   LanguageMode language_mode() const;
 
   void AssignFeedbackSlots(FeedbackVectorSpec* spec, LanguageMode language_mode,
                            FeedbackSlotCache* cache) {
     literal_feedback_slot_ = spec->AddCreateClosureSlot();
   }
 
+  void SetTypeProfileSlot(FeedbackSlot slot) { type_profile_slot_ = slot; }
+
   FeedbackSlot LiteralFeedbackSlot() const { return literal_feedback_slot_; }
+  FeedbackSlot TypeProfileSlot() const { return type_profile_slot_; }
 
   static bool NeedsHomeObject(Expression* expr);
 
   int expected_property_count() { return expected_property_count_; }
   int parameter_count() { return parameter_count_; }
   int function_length() { return function_length_; }
 
   bool AllowsLazyCompilation();
 
   Handle<String> debug_name() const {
@@ skipping 142 matching lines @@
   bool has_braces_;
 
   const AstString* raw_name_;
   DeclarationScope* scope_;
   ZoneList<Statement*>* body_;
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
   int function_literal_id_;
   FeedbackSlot literal_feedback_slot_;
+  FeedbackSlot type_profile_slot_;
 };
 
 // Property is used for passing information
 // about a class literal's properties from the parser to the code generator.
 class ClassLiteralProperty final : public LiteralProperty {
  public:
   enum Kind : uint8_t { METHOD, GETTER, SETTER, FIELD };
 
   Kind kind() const { return kind_; }
 
@@ skipping 876 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_