Stop making classes implicitly abstract

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 515 matching lines @@
 
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(const Class& cls,
             const String& cls_name,
             bool is_interface,
             intptr_t token_pos)
       : clazz_(cls),
         class_name_(cls_name),
         is_interface_(is_interface),
-        is_abstract_(false),
         token_pos_(token_pos),
         functions_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
         fields_(GrowableObjectArray::Handle(GrowableObjectArray::New())) {
   }
 
   bool FunctionNameExists(const String& name, RawFunction::Kind kind) const {
     // First check if a function or field of same name exists.
     if (NameExists<Function>(functions_, name) ||
         NameExists<Field>(fields_, name)) {
       return true;
@@ skipping 55 matching lines @@
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
   bool is_interface() const {
     return is_interface_;
   }
 
-  void set_is_abstract() {
-    is_abstract_ = true;
-  }
-
-  bool is_abstract() const {
-    return is_abstract_;
-  }
-
   bool has_constructor() const {
     Function& func = Function::Handle();
     for (int i = 0; i < functions_.Length(); i++) {
       func ^= functions_.At(i);
       if (func.kind() == RawFunction::kConstructor) {
         return true;
       }
     }
     return false;
   }
@@ skipping 30 matching lines @@
       if (name.Equals(test_name)) {
         return true;
       }
     }
     return false;
   }
 
   const Class& clazz_;
   const String& class_name_;
   const bool is_interface_;
-  bool is_abstract_;
   intptr_t token_pos_;   // Token index of "class" keyword.
   GrowableObjectArray& functions_;
   GrowableObjectArray& fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
 struct TopLevel {
   TopLevel() :
       fields(GrowableObjectArray::Handle(GrowableObjectArray::New())),
@@ skipping 1914 matching lines @@
                     method->has_external,
                     current_class(),
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   members->AddFunction(func);
-  if (method->has_abstract) {
-    members->set_is_abstract();
-  }
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
@@ skipping 487 matching lines @@
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     SkipMetadata();
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
-  if (is_abstract || members.is_abstract()) {
+  if (is_abstract) {
     cls.set_is_abstract();
   }
 
   // Add an implicit constructor if no explicit constructor is present. No
   // implicit constructors are needed for patch classes.
   if (!members.has_constructor() && !is_patch) {
     AddImplicitConstructor(&members);
   }
   CheckConstructors(&members);
 
@@ skipping 6396 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart