Add compiler error when instantiating abstract class

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 479 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 1833 matching lines @@
     } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor '%s' may not have a function body",
                method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     ParseNativeDeclaration();
-  } else if (CurrentToken() == Token::kSEMICOLON) {
-    if (members->is_interface() ||
-        method->has_abstract ||
-        method->has_external ||
-        (method->redirect_name != NULL) ||
-        method->IsConstructor()) {
-      ConsumeToken();
-    } else {
+  } else {
+    // We haven't found a method body. Issue error if one is required.
+    const bool must_have_body =
+        !members->is_interface() &&
+        method->has_static && !method->has_external;
+    if (must_have_body) {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
-  } else {
-    if (members->is_interface() ||
-        method->has_abstract ||
-        method->has_external ||
-        (method->redirect_name != NULL) ||
-        (method->IsConstructor() && method->has_const)) {
-      ExpectSemicolon();
+
+    if (CurrentToken() == Token::kSEMICOLON) {
+      ConsumeToken();
+      if (!members->is_interface() &&
+          !method->has_static &&
+          !method->has_external &&
+          !method->IsConstructor()) {
+          // Methods, getters and setters without a body are
+          // implicitly abstract.
+        method->has_abstract = true;
+      }
     } else {
-      ErrorMsg(method->name_pos,
-               "function body expected for method '%s'",
-               method->name->ToCString());
+      // Signature is not followed by semicolon or body. Issue an
+      // appropriate error.
+      const bool must_have_semicolon =
+          members->is_interface() ||
+          (method->redirect_name != NULL) ||
+          (method->IsConstructor() && method->has_const) ||
+          method->has_external;
+      if (must_have_semicolon) {
+        ExpectSemicolon();
+      } else {
+        ErrorMsg(method->name_pos,
+                 "function body or semicolon expected for method '%s'",
+                 method->name->ToCString());
+      }
     }
   }
 
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
   Function& func = Function::Handle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     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 383 matching lines @@
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseClassDefinition");
-  const intptr_t class_pos = TokenPos();
   bool is_patch = false;
+  bool is_abstract = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
+  } else if (CurrentToken() == Token::kABSTRACT) {
+    is_abstract = true;
+    ConsumeToken();
   }
+  const intptr_t class_pos = TokenPos();
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = TokenPos();
   String& class_name = *ExpectClassIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
   Class& cls = Class::Handle();
   Object& obj = Object::Handle(library_.LookupLocalObject(class_name));
   if (obj.IsNull()) {
     if (is_patch) {
@@ skipping 67 matching lines @@
     AddInterfaces(interfaces_pos, cls, interfaces);
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
+  if (is_abstract || members.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);
   }
   CheckConstructorCycles(&members);
 
   Array& array = Array::Handle();
   array = Array::MakeArray(members.fields());
   cls.SetFields(array);
@@ skipping 1028 matching lines @@
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(pending_classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
       ParseInterfaceDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
-      ConsumeToken();  // Consume and ignore 'abstract'.
       ParseClassDefinition(pending_classes);
     } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDefinition(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
       } else if (IsFunctionDeclaration()) {
         ParseTopLevelFunction(&top_level);
@@ skipping 4362 matching lines @@
   // In that case, we throw a dynamic type error instead of calling the
   // constructor.
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
              String::Handle(type.UserVisibleName()).ToCString());
   }
   if (type.IsDynamicType()) {
     ErrorMsg(type_pos, "Dynamic cannot be instantiated");
   }
-  Class& type_class = Class::Handle(type.type_class());
-  String& type_class_name = String::Handle(type_class.Name());
+  const Class& type_class = Class::Handle(type.type_class());
+  const String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
   // The constructor class and its name are those of the parsed type, unless the
   // parsed type is an interface and a default factory class is specified, in
   // which case constructor_class and constructor_class_name are modified below.
   Class& constructor_class = Class::ZoneHandle(type_class.raw());
   String& constructor_class_name = String::Handle(type_class_name.raw());
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
@@ skipping 84 matching lines @@
     arguments_length -= 1;
   }
   if (constructor.IsNull()) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
     ErrorMsg(type_pos,
              "class '%s' has no constructor or factory named '%s'",
              String::Handle(constructor_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
+
+  // It is ok to call a factory method of an abstract class, but it is
+  // an error to instantiate an abstract class.
+  if (constructor_class.is_abstract() && !constructor.IsFactory()) {
+    ErrorMsg(type_pos, "Cannot instantiate abstract class %s",
+             constructor_class_name.ToCString());
+  }
+
   String& error_message = String::Handle();
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
     ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s' for class '%s': %s",
              external_constructor_name.ToCString(),
              String::Handle(constructor_class.Name()).ToCString(),
@@ skipping 665 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart