Cleanup obsolete setter code

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 2029 matching lines @@
                        function_name,
                        arguments,
                        kResolveGetter,
                        &is_no_such_method));
   if (super_function.IsGetterFunction() ||
       super_function.IsImplicitGetterFunction()) {
     const Class& super_class =
         Class::ZoneHandle(Z, current_class().SuperClass());
     AstNode* closure = new StaticGetterNode(supercall_pos,
                                             LoadReceiver(supercall_pos),
-                                            /* is_super_getter */ true,
                                             super_class,
                                             function_name);
     // 'this' is not passed as parameter to the closure.
     ArgumentListNode* closure_arguments = new ArgumentListNode(supercall_pos);
     for (int i = 1; i < arguments->length(); i++) {
       closure_arguments->Add(arguments->NodeAt(i));
     }
     return BuildClosureCall(supercall_pos, closure, closure_arguments);
   }
   if (is_no_such_method) {
@@ skipping 152 matching lines @@
         // In case CreateAssignmentNode is called later on this
         // CreateImplicitClosureNode, it will be replaced by a StaticSetterNode.
         return CreateImplicitClosureNode(super_function,
                                          field_pos,
                                          implicit_argument);
       }
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
   }
-  return new StaticGetterNode(
-      field_pos, implicit_argument, true, super_class, field_name);
+  return new(Z) StaticGetterNode(
+      field_pos, implicit_argument, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           intptr_t supercall_pos,
                                           LocalVariable* receiver,
                                           AstNode* phase_parameter,
                                           ArgumentListNode* forwarding_args) {
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
@@ skipping 8565 matching lines @@
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         closure = new(Z) StaticGetterNode(
             call_pos,
             NULL,
-            false,
             Class::ZoneHandle(Z, cls.raw()),
             func_name);
         return BuildClosureCall(call_pos, closure, arguments);
       }
     } else {
       closure = GenerateStaticFieldLookup(field, call_pos);
       return BuildClosureCall(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos,
@@ skipping 59 matching lines @@
   const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
   // Never load field directly if there is a getter (deterministic AST).
   if (getter.IsNull() || field.is_const()) {
     return new(Z) LoadStaticFieldNode(
         ident_pos, Field::ZoneHandle(Z, field.raw()));
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
     return new(Z) StaticGetterNode(ident_pos,
                                    NULL,  // Receiver.
-                                   false,  // is_super_getter.
                                    field_owner,
                                    field_name);
   }
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         intptr_t ident_pos,
                                         bool consume_cascades) {
@@ skipping 17 matching lines @@
       if (!func.IsNull()) {
         access = CreateImplicitClosureNode(func, ident_pos, NULL);
       } else {
         // No function to closurize found found.
         // This field access may turn out to be a call to the setter.
         // Create a getter call, which may later be turned into
         // a setter call, or else the backend will generate
         // a throw NoSuchMethodError().
         access = new(Z) StaticGetterNode(ident_pos,
                                          NULL,
-                                         false,
                                          Class::ZoneHandle(Z, cls.raw()),
                                          field_name);
       }
     } else {
       ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
       access = new(Z) StaticGetterNode(
-          ident_pos, NULL, false, Class::ZoneHandle(Z, cls.raw()), field_name);
+          ident_pos, NULL, Class::ZoneHandle(Z, cls.raw()), field_name);
     }
   } else {
     access = GenerateStaticFieldLookup(field, ident_pos);
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
   PrimaryNode* primary = node->AsPrimaryNode();
   if (primary->primary().IsString()) {
     if (primary->IsSuper()) {
       return primary;
     }
     // In a static method, evaluation of an unresolved identifier causes a
     // NoSuchMethodError to be thrown.
     // In an instance method, we convert this into a getter call
     // for a field (which may be defined in a subclass.)
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       StaticGetterNode* getter = new(Z) StaticGetterNode(
           primary->token_pos(),
           NULL,  // No receiver.
-          false,  // Not a super getter.
           Class::ZoneHandle(Z, current_class().raw()),
           name);
       getter->set_is_deferred(primary->is_deferred_reference());
       return getter;
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
@@ skipping 499 matching lines @@
   const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(Z, field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ReportError("circular dependency while initializing static field '%s'",
                   field_name.ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new(Z) StaticGetterNode(
-          field_ref_pos, NULL, false, field_owner, field_name);
+          field_ref_pos, NULL, field_owner, field_name);
     }
   } else if (value.raw() == Object::sentinel().raw()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const int kNumArguments = 0;  // no arguments.
       const Function& func = Function::Handle(Z,
           Resolver::ResolveStatic(field_owner,
@@ skipping 28 matching lines @@
         UNREACHABLE();
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle(Z);
       instance ^= const_value.raw();
       instance = TryCanonicalize(instance, field_ref_pos);
       field.set_value(instance);
       return NULL;   // Constant
     } else {
       return new(Z) StaticGetterNode(
-          field_ref_pos, NULL, false, field_owner, field_name);
+          field_ref_pos, NULL, field_owner, field_name);
     }
   }
   if (getter.IsNull() ||
       (getter.kind() == RawFunction::kImplicitStaticFinalGetter)) {
     return NULL;
   }
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
   return new(Z) StaticGetterNode(
-      field_ref_pos, NULL, false, field_owner, field_name);
+      field_ref_pos, NULL, field_owner, field_name);
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 2 extra arguments: rcvr and construction phase.
@@ skipping 117 matching lines @@
   if (!func.IsNull()) {
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
-        ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
-        // The static getter may later be changed into a dynamically
-        // resolved instance setter if no static setter can
-        // be found.
-        AstNode* receiver = NULL;
-        const bool kTestOnly = true;
-        if (!current_function().is_static() &&
-            (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
-          receiver = LoadReceiver(ident_pos);
-        }
         *node = new(Z) StaticGetterNode(ident_pos,
-                                        receiver,
-                                        false,
+                                        NULL,
                                         Class::ZoneHandle(Z, cls.raw()),
                                         ident);
       }
       return true;
     }
   }
   func = cls.LookupSetterFunction(ident);
   if (!func.IsNull()) {
+    // We create a getter node even though a getter doesn't exist as
+    // it could be followed by an assignment which will convert it to
+    // a setter node. If there is no assignment we will get an error
+    // when we try to invoke the getter.
     if (func.IsDynamicFunction() || func.is_abstract()) {
       if (node != NULL) {
-        // We create a getter node even though a getter doesn't exist as
-        // it could be followed by an assignment which will convert it to
-        // a setter node. If there is no assignment we will get an error
-        // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
-        // We create a getter node even though a getter doesn't exist as
-        // it could be followed by an assignment which will convert it to
-        // a setter node. If there is no assignment we will get an error
-        // when we try to invoke the getter.
-        *node = new(Z) StaticGetterNode(
-            ident_pos,
-            NULL,
-            false,
-            Class::ZoneHandle(Z, cls.raw()),
-            ident);
+        *node = new(Z) StaticGetterNode(ident_pos,
+                                        NULL,
+                                        Class::ZoneHandle(Z, cls.raw()),
+                                        ident);
       }
       return true;
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;  // Not an unqualified identifier.
@@ skipping 24 matching lines @@
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, ident_pos);
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       return new(Z) StaticGetterNode(ident_pos,
                                      /* receiver */ NULL,
-                                     /* is_super_getter */ false,
                                      Class::ZoneHandle(Z, func.Owner()),
                                      ident);
 
     } else {
       return new(Z) PrimaryNode(ident_pos, Function::ZoneHandle(Z, func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
@@ skipping 63 matching lines @@
       get_field->AsStaticGetterNode()->set_is_deferred(is_deferred);
     }
     return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       StaticGetterNode* getter = new(Z) StaticGetterNode(
           ident_pos,
           /* receiver */ NULL,
-          /* is_super_getter */ false,
           Class::ZoneHandle(Z, func.Owner()),
           ident);
       getter->set_is_deferred(is_deferred);
       return getter;
     } else {
       PrimaryNode* primary = new(Z) PrimaryNode(
            ident_pos, Function::ZoneHandle(Z, func.raw()));
       primary->set_is_deferred(is_deferred);
       return primary;
     }
@@ skipping 1657 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart