Removing all incr-op nodes.

runtime/vm/ast.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/ast.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object_store.h"
 
@@ skipping 280 matching lines @@
       return NULL;
   }
 }
 
 
 const char* UnaryOpNode::Name() const {
   return Token::Str(kind_);
 }
 
 
-const char* IncrOpInstanceFieldNode::Name() const {
-  switch (kind_) {
-    case Token::kINCR:
-      return prefix_ ? "instance_field_pre_++" : "instance_field_post_++";
-    case Token::kDECR:
-      return prefix_ ? "instance_field_pre_--" : "instance_field_post_--";
-    default:
-      UNREACHABLE();
-      return NULL;
-  }
-}
-
-
 const char* JumpNode::Name() const {
   return Token::Str(kind_);
 }
 
 
-const char* IncrOpIndexedNode::Name() const {
-  switch (kind_) {
-    case Token::kINCR:
-      return prefix_ ? "indexed_pre_++" : "indexed_post_++";
-    case Token::kDECR:
-      return prefix_ ? "indexed_pre_--" : "indexed_post_--";
-    default:
-      UNREACHABLE();
-      return NULL;
-  }
-}
-
-
 AstNode* LoadLocalNode::MakeAssignmentNode(AstNode* rhs) {
   if (local().is_final()) {
     return NULL;
   }
   if (HasPseudo()) {
     return NULL;
   }
   return new StoreLocalNode(token_index(), local(), rhs);
 }
 
 
-AstNode* LoadLocalNode::MakeIncrOpNode(intptr_t token_index,
-                                       Token::Kind kind,
-                                       bool is_prefix) {
-  if (local().is_final()) {
-    return NULL;
-  }
-  if (is_prefix) {
-    const Instance& literal = Instance::ZoneHandle(Smi::New(1));
-    AstNode* lhs = this;
-    LiteralNode* rhs = new LiteralNode(token_index, literal);
-    Token::Kind binop_kind = (kind == Token::kINCR) ? Token::kADD : Token::kSUB;
-    BinaryOpNode* result = new BinaryOpNode(token_index, binop_kind, lhs, rhs);
-    StoreLocalNode* store = new StoreLocalNode(token_index, local(), result);
-    return store;
-  }
-  UNIMPLEMENTED();
-  return NULL;
-}
-
-
 AstNode* LoadStaticFieldNode::MakeAssignmentNode(AstNode* rhs) {
   return new StoreStaticFieldNode(token_index(), field(), rhs);
 }
 
 
-AstNode* LoadStaticFieldNode::MakeIncrOpNode(intptr_t token_index,
-                                             Token::Kind kind,
-                                             bool is_prefix) {
-  UNIMPLEMENTED();
-  return NULL;
-}
-
-
 AstNode* InstanceGetterNode::MakeAssignmentNode(AstNode* rhs) {
   return new InstanceSetterNode(token_index(), receiver(), field_name(), rhs);
 }
 
 
-AstNode* InstanceGetterNode::MakeIncrOpNode(intptr_t token_index,
-                                            Token::Kind kind,
-                                            bool is_prefix) {
-  return new IncrOpInstanceFieldNode(token_index,
-                                     kind,
-                                     is_prefix,
-                                     receiver(),
-                                     field_name());
-}
-
-
 AstNode* LoadIndexedNode::MakeAssignmentNode(AstNode* rhs) {
   return new StoreIndexedNode(token_index(), array(), index_expr(), rhs);
 }
 
 
-AstNode* LoadIndexedNode::MakeIncrOpNode(intptr_t token_index,
-                                         Token::Kind kind,
-                                         bool is_prefix) {
-  return new IncrOpIndexedNode(token_index,
-                               kind,
-                               is_prefix,
-                               array(),
-                               index_expr());
-}
-
-
 AstNode* StaticGetterNode::MakeAssignmentNode(AstNode* rhs) {
   // If no setter exist, set the field directly.
   const String& setter_name = String::Handle(Field::SetterName(field_name()));
   const Function& setter =
       Function::ZoneHandle(cls().LookupStaticFunction(setter_name));
   if (setter.IsNull()) {
     // Access to a lazily initialized static field that has not yet been
     // initialized is compiled to a static implicit getter.
     // A setter may not exist for such a field.
 #if defined(DEBUG)
     const String& getter_name = String::Handle(Field::GetterName(field_name()));
     const Function& getter =
         Function::ZoneHandle(cls().LookupStaticFunction(getter_name));
     ASSERT(!getter.IsNull() &&
            (getter.kind() == RawFunction::kConstImplicitGetter));
 #endif
     const Field& field = Field::ZoneHandle(
         cls().LookupStaticField(field_name()));
     ASSERT(!field.IsNull());
     return new StoreStaticFieldNode(token_index(), field, rhs);
   } else {
     return new StaticSetterNode(token_index(), cls(), field_name(), rhs);
   }
 }
 
 
-AstNode* StaticGetterNode::MakeIncrOpNode(intptr_t token_index,
-                                          Token::Kind kind,
-                                          bool is_prefix) {
-  UNIMPLEMENTED();
-  return NULL;
-}
-
-
 const Instance* StaticGetterNode::EvalConstExpr() const {
   const String& getter_name =
       String::Handle(Field::GetterName(this->field_name()));
   const Function& getter_func =
       Function::Handle(this->cls().LookupStaticFunction(getter_name));
   if (getter_func.IsNull() || !getter_func.is_const()) {
     return NULL;
   }
   GrowableArray<const Object*> arguments;
   const Array& kNoArgumentNames = Array::Handle();
   const Object& result =
       Object::Handle(DartEntry::InvokeStatic(getter_func,
                                              arguments,
                                              kNoArgumentNames));
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   Instance& field_value = Instance::ZoneHandle();
   field_value ^= result.raw();
   return &field_value;
 }
 
 }  // namespace dart