Cleanups.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 878 matching lines @@
     } else {
       const Object& const_value = ParseConstExpr()->literal();
       parameter.default_value = &const_value;
     }
   } else {
     if (params->has_named_optional_parameters) {
       // Implicit default value is null.
       params->num_optional_parameters++;
       parameter.default_value = &Object::ZoneHandle();
     } else {
-      // TODO(regis): Remove support of legacy syntax.
       params->num_fixed_parameters++;
-      if (params->num_optional_parameters > 0) {
-        ErrorMsg("optional parameters must be last");
-      }
+      ASSERT(params->num_optional_parameters == 0);
     }
   }
   if (parameter.type->IsVoidType()) {
     ErrorMsg("parameter '%s' may not be 'void'", parameter.name->ToCString());
   }
   params->parameters->Add(parameter);
 }
 
 
 void Parser::ParseFormalParameterList(bool allow_explicit_default_values,
@@ skipping 1236 matching lines @@
     member.kind = RawFunction::kGetterFunction;
     member.name_pos = this->token_index_;
     member.name = ExpectIdentifier("identifier expected");
     // If the result type was not specified, it will be set to VarType below.
   } else if (CurrentToken() == Token::kSET) {
     ConsumeToken();
     member.kind = RawFunction::kSetterFunction;
     member.name_pos = this->token_index_;
     member.name = ExpectIdentifier("identifier expected");
     // The grammar allows a return type, so member.type is not always NULL here.
-    // However, the return type of a setter is ignored.
-    // TODO(regis): Revisit depending on the outcome of issue 4745047.
+    // If no return type is specified, the return type of the setter is Dynamic.
     if (member.type == NULL) {
-      member.type = &Type::ZoneHandle(Type::VoidType());
+      member.type = &Type::ZoneHandle(Type::VarType());
     }
   } else if (CurrentToken() == Token::kOPERATOR) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     member.kind = RawFunction::kFunction;
@@ skipping 462 matching lines @@
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   GrowableArray<Type*> interfaces;
   do {
     ConsumeToken();
-    // TODO(regis): The way we handle unresolved classes is not going to fly.
-    // We are currently not able to provide a token position for errors occuring
-    // after parsing, as in the class finalizer. We need to introduce an
-    // 'unresolved class' class consisting of a string, a token position, and a
-    // script, maybe a library too.
     Type& interface = Type::ZoneHandle(ParseType(kCanResolve));
     interfaces.Add(&interface);
   } while (CurrentToken() == Token::kCOMMA);
   return NewArray<Type>(interfaces);
 }
 
 
 void Parser::AddInterfaces(intptr_t interfaces_pos,
                            const Class& cls,
                            const Array& interfaces) {
@@ skipping 120 matching lines @@
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   const bool is_static = true;
   Type& result_type = Type::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
-    // TODO(regis): Revisit, see issue 4745047.
     result_type = Type::VarType();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else {
       result_type = ParseType(kCanResolve);
     }
     is_getter = (CurrentToken() == Token::kGET);
     if (CurrentToken() == Token::kGET || CurrentToken() == Token::kSET) {
@@ skipping 4202 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart