Catch illegally declared constructors

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2313 matching lines @@
     ErrorMsg(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
     ErrorMsg(method->name_pos,
              "static method '%s' cannot be abstract",
              method->name->ToCString());
   }
   if (method->has_const && !(method->IsConstructor() || method->IsFactory())) {
     ErrorMsg(method->name_pos, "'const' not allowed for methods");
   }
-  if (method->IsConstructor() && method->has_static) {
-    ErrorMsg(method->name_pos, "constructor cannot be 'static'");
+  if (method->IsFactoryOrConstructor() && method->has_abstract) {
+    ErrorMsg(method->name_pos, "constructor cannot be abstract");
   }
   if (method->IsConstructor() && method->has_const) {
     Class& cls = Class::ZoneHandle(library_.LookupClass(members->class_name()));
     cls.set_is_const();
   }
   if (method->has_abstract && members->is_interface()) {
     ErrorMsg(method->name_pos,
              "'abstract' method only allowed in class definition");
   }
   if (method->has_external && members->is_interface()) {
@@ skipping 436 matching lines @@
     }
     if (member.has_final) {
       ErrorMsg("identifier expected after 'final'");
     }
     ConsumeToken();
     member.has_var = true;
     // The member type is the 'Dynamic' type.
     member.type = &Type::ZoneHandle(Type::DynamicType());
   } else if (CurrentToken() == Token::kFACTORY) {
     ConsumeToken();
+    if (member.has_static) {
+      ErrorMsg("factory method cannot be explicitly marked static");
+    }
     member.has_factory = true;
     member.has_static = true;
     // The result type depends on the name of the factory method.
   }
   // Optionally parse a type.
   if (CurrentToken() == Token::kVOID) {
     if (member.has_var || member.has_factory) {
       ErrorMsg("void not expected");
     }
     ConsumeToken();
@@ skipping 40 matching lines @@
       }
       const Object& result_type_class = Object::Handle(
           UnresolvedClass::New(lib_prefix,
                                *factory_name.ident,
                                factory_name.ident_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
                                                 factory_name.ident_pos));
     } else {
+      if (member.has_static) {
+        ErrorMsg("constructor cannot be static");
+      }
       member.name_pos = TokenPos();
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
@@ skipping 6507 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart