Small code cleanup in the parser.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 1555 matching lines @@
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
     const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
     ASSERT(!super_class.IsNull());
     super_op =
         new LoadIndexedNode(operator_pos, receiver, index_expr, super_class);
-  } else if (Token::CanBeOverloaded(CurrentToken()) ||
-             (CurrentToken() == Token::kNE)) {
+  } else {
+    ASSERT(Token::CanBeOverloaded(CurrentToken()) ||
+           (CurrentToken() == Token::kNE));
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
     bool negate_result = false;
     if (op == Token::kNE) {
       op = Token::kEQ;
       negate_result = true;
     }
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
@@ skipping 61 matching lines @@
 
   const String& getter_name =
       String::ZoneHandle(Field::GetterName(field_name));
   const Function& super_getter = Function::ZoneHandle(
       Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     const String& setter_name =
         String::ZoneHandle(Field::SetterName(field_name));
     const Function& super_setter = Function::ZoneHandle(
         Resolver::ResolveDynamicAnyArgs(super_class, setter_name));
-    if (!super_setter.IsNull()) {
-      return new StaticGetterNode(
-          field_pos, implicit_argument, true, super_class, field_name);
+    if (super_setter.IsNull()) {
+      // Check if this is an access to an implicit closure using 'super'.
+      // If a function exists of the specified field_name then try
+      // accessing it as a getter, at runtime we will handle this by
+      // creating an implicit closure of the function and returning it.
+      const Function& super_function = Function::ZoneHandle(
+          Resolver::ResolveDynamicAnyArgs(super_class, field_name));
+      if (!super_function.IsNull()) {
+        // 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.
     }
   }
-  if (super_getter.IsNull()) {
-    // Check if this is an access to an implicit closure using 'super'.
-    // If a function exists of the specified field_name then try
-    // accessing it as a getter, at runtime we will handle this by
-    // creating an implicit closure of the function and returning it.
-    const Function& super_function = Function::ZoneHandle(
-        Resolver::ResolveDynamicAnyArgs(super_class, field_name));
-    if (!super_function.IsNull()) {
-      // 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);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           LocalVariable* receiver) {
   const intptr_t supercall_pos = TokenPos();
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
@@ skipping 8302 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart