[Kernel] Remove code from the old type propagation.

runtime/vm/kernel.h

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_KERNEL_H_
 #define RUNTIME_VM_KERNEL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/token_position.h"
 
 
 #define KERNEL_NODES_DO(M)                                                     \
   M(Name)                                                                      \
-  M(InferredValue)                                                             \
   M(DartType)                                                                  \
   M(InvalidType)                                                               \
   M(DynamicType)                                                               \
   M(VoidType)                                                                  \
   M(InterfaceType)                                                             \
   M(FunctionType)                                                              \
   M(TypeParameterType)
 
 #define KERNEL_TREE_NODES_DO(M)                                                \
   M(Library)                                                                   \
@@ skipping 665 matching lines @@
   virtual void AcceptMemberVisitor(MemberVisitor* visitor);
   virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
   bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; }
   intptr_t source_uri_index() { return source_uri_index_; }
 
   DartType* type() { return type_; }
-  InferredValue* inferred_value() { return inferred_value_; }
   Expression* initializer() { return initializer_; }
 
  private:
   Field() {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   intptr_t source_uri_index_;
   Child<DartType> type_;
-  Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
 
   DISALLOW_COPY_AND_ASSIGN(Field);
 };
 
 
 class Constructor : public Member {
  public:
   enum Flags {
     kFlagConst = 1 << 0,
@@ skipping 235 matching lines @@
 
   AsyncMarker async_marker() { return async_marker_; }
   AsyncMarker dart_async_marker() { return dart_async_marker_; }
   TypeParameterList& type_parameters() { return type_parameters_; }
   int required_parameter_count() { return required_parameter_count_; }
   List<VariableDeclaration>& positional_parameters() {
     return positional_parameters_;
   }
   List<VariableDeclaration>& named_parameters() { return named_parameters_; }
   DartType* return_type() { return return_type_; }
-  InferredValue* inferred_return_value() { return inferred_return_value_; }
   Statement* body() { return body_; }
   TokenPosition position() { return position_; }
   TokenPosition end_position() { return end_position_; }
 
  private:
   FunctionNode()
       : position_(TokenPosition::kNoSource),
         end_position_(TokenPosition::kNoSource) {}
 
   AsyncMarker async_marker_;
   AsyncMarker dart_async_marker_;
   TypeParameterList type_parameters_;
   int required_parameter_count_;
   List<VariableDeclaration> positional_parameters_;
   List<VariableDeclaration> named_parameters_;
   Child<DartType> return_type_;
-  Child<InferredValue> inferred_return_value_;
   Child<Statement> body_;
   TokenPosition position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionNode);
 };
 
 
 class Expression : public TreeNode {
  public:
@@ skipping 1462 matching lines @@
   DEFINE_CASTING_OPERATIONS(VariableDeclaration);
 
   virtual void AcceptStatementVisitor(StatementVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
 
   bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; }
   bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; }
 
   String* name() { return name_; }
   DartType* type() { return type_; }
-  InferredValue* inferred_value() { return inferred_value_; }
   Expression* initializer() { return initializer_; }
   TokenPosition equals_position() { return equals_position_; }
   TokenPosition end_position() { return end_position_; }
   void set_end_position(TokenPosition position) { end_position_ = position; }
 
  private:
   VariableDeclaration()
       : equals_position_(TokenPosition::kNoSourcePos),
         end_position_(TokenPosition::kNoSource) {}
 
   template <typename T>
   friend class List;
 
   word flags_;
   Ref<String> name_;
   Child<DartType> type_;
-  Child<InferredValue> inferred_value_;
   Child<Expression> initializer_;
   TokenPosition equals_position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(VariableDeclaration);
 };
 
 
 class FunctionDeclaration : public Statement {
  public:
@@ skipping 41 matching lines @@
   Name(String* string, CanonicalName* library_reference)
       : string_(string), library_reference_(library_reference) {}  // NOLINT
 
   Ref<String> string_;
   Ref<CanonicalName> library_reference_;
 
   DISALLOW_COPY_AND_ASSIGN(Name);
 };
 
 
-class InferredValue : public Node {
- public:
-  static const uint8_t kNull = 1 << 0;
-  static const uint8_t kInteger = 1 << 1;
-  static const uint8_t kDouble = 1 << 2;
-  static const uint8_t kString = 1 << 3;
-  static const uint8_t kOther = 1 << 4;
-
-  enum BaseClassKind {
-    kNone,
-    kExact,
-    kSubclass,
-    kSubtype,
-  };
-
-  static InferredValue* ReadFrom(Reader* reader);
-
-  virtual ~InferredValue();
-
-  DEFINE_CASTING_OPERATIONS(InferredValue);
-
-  virtual void AcceptVisitor(Visitor* visitor);
-  virtual void VisitChildren(Visitor* visitor);
-
-  bool IsInterfaceType() { return kind_ == kSubtype; }
-  bool IsExactClass() { return kind_ == kExact; }
-  bool IsSubclass() { return kind_ == kSubclass; }
-
-  bool CanBeNull() { return (value_bits_ & kNull) != 0; }
-  bool CanBeInteger() { return (value_bits_ & kInteger) != 0; }
-  bool CanBeDouble() { return (value_bits_ & kDouble) != 0; }
-  bool CanBeString() { return (value_bits_ & kString) != 0; }
-
-  bool IsAlwaysNull() { return value_bits_ == kNull; }
-  bool IsAlwaysInteger() { return value_bits_ == kInteger; }
-  bool IsAlwaysDouble() { return value_bits_ == kDouble; }
-  bool IsAlwaysString() { return value_bits_ == kString; }
-
-  Class* klass() { return klass_reference_->AsClass(); }
-  BaseClassKind kind() { return kind_; }
-  uint8_t value_bits() { return value_bits_; }
-
- private:
-  InferredValue() {}
-
-  Ref<CanonicalName> klass_reference_;
-  BaseClassKind kind_;
-  uint8_t value_bits_;
-
-  DISALLOW_COPY_AND_ASSIGN(InferredValue);
-};
-
-
 class DartType : public Node {
  public:
   static DartType* ReadFrom(Reader* reader);
 
   virtual ~DartType();
 
   DEFINE_CASTING_OPERATIONS(DartType);
 
   virtual void AcceptVisitor(Visitor* visitor);
   virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor) = 0;
@@ skipping 525 matching lines @@
 
 
 class Visitor : public TreeVisitor,
                 public DartTypeVisitor,
                 public ClassReferenceVisitor,
                 public MemberReferenceVisitor {
  public:
   virtual ~Visitor() {}
 
   virtual void VisitDefaultNode(Node* node) = 0;
-  virtual void VisitInferredValue(InferredValue* node) {
-    VisitDefaultNode(node);
-  }
   virtual void VisitDefaultTreeNode(TreeNode* node) { VisitDefaultNode(node); }
   virtual void VisitDefaultDartType(DartType* node) { VisitDefaultNode(node); }
   virtual void VisitName(Name* node) { VisitDefaultNode(node); }
   virtual void VisitDefaultClassReference(Class* node) {
     VisitDefaultNode(node);
   }
   virtual void VisitDefaultMemberReference(Member* node) {
     VisitDefaultNode(node);
   }
 };
@@ skipping 83 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
 
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_