Implement enum types in VM

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 "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 714 matching lines @@
 
 void Parser::ParseClass(const Class& cls) {
   if (!cls.is_synthesized_class()) {
     Isolate* isolate = Isolate::Current();
     TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
     ASSERT(isolate->long_jump_base()->IsSafeToJump());
     const Script& script = Script::Handle(isolate, cls.script());
     const Library& lib = Library::Handle(isolate, cls.library());
     Parser parser(script, lib, cls.token_pos());
     parser.ParseClassDefinition(cls);
+  } else if (cls.is_enum_class()) {
+    Isolate* isolate = Isolate::Current();
+    TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+    ASSERT(isolate->long_jump_base()->IsSafeToJump());
+    const Script& script = Script::Handle(isolate, cls.script());
+    const Library& lib = Library::Handle(isolate, cls.library());
+    Parser parser(script, lib, cls.token_pos());
+    parser.ParseEnumDefinition(cls);
   }
 }
 
 
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
   ASSERT(!func.IsNull());
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 373 matching lines @@
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
-  ASSERT(IsIdentifier());
-  const String& field_name = *CurrentLiteral();
+  String& field_name = String::Handle(I, func.name());
+  field_name = Field::NameFromGetter(field_name);
+
   const Class& field_class = Class::Handle(I, func.Owner());
   const Field& field =
       Field::ZoneHandle(I, field_class.LookupInstanceField(field_name));
+  ASSERT(!field.IsNull());
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
   ReturnNode* return_node = new ReturnNode(Scanner::kNoSourcePos, load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
@@ skipping 1901 matching lines @@
   } else if (func.is_async_closure()) {
     OpenAsyncClosure();
   }
 
   bool saved_await_is_keyword = await_is_keyword_;
   await_is_keyword_ = func.IsAsyncFunction() || func.is_async_closure();
 
   intptr_t end_token_pos = 0;
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
-    if (String::Handle(I, func.name()).Equals(
-        Symbols::EqualOperator())) {
+    if (String::Handle(I, func.name()).Equals(Symbols::EqualOperator())) {
       const Class& owner = Class::Handle(I, func.Owner());
       if (!owner.IsObjectClass()) {
         AddEqualityNullCheck();
       }
     }
     ParseStatementSequence();
     end_token_pos = TokenPos();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
@@ skipping 929 matching lines @@
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
 
 
+void Parser::ParseEnumDeclaration(const GrowableObjectArray& pending_classes,
+                                  const Class& toplevel_class,
+                                  intptr_t metadata_pos) {
+  TRACE_PARSER("ParseEnumDeclaration");
+  ConsumeToken();
+  const intptr_t enum_pos = TokenPos();
+  String* enum_name =
+      ExpectUserDefinedTypeIdentifier("enum type name expected");
+  if (FLAG_trace_parser) {
+    OS::Print("TopLevel parsing enum '%s'\n", enum_name->ToCString());
+  }
+  ExpectToken(Token::kLBRACE);
+  if (!IsIdentifier()) {
+    ReportError("Enumeration must have at least one name");
+  }
+  while (IsIdentifier()) {
+    ConsumeToken();
+    if (CurrentToken() == Token::kCOMMA) {
+      ConsumeToken();
+      if (CurrentToken() == Token::kRBRACE) {
+        break;
+      }
+    } else if (CurrentToken() == Token::kRBRACE) {
+      break;
+    } else {
+      ReportError(", or } expected");
+    }
+  }
+  ExpectToken(Token::kRBRACE);
+
+  Object& obj = Object::Handle(I, library_.LookupLocalObject(*enum_name));
+  if (!obj.IsNull()) {
+    ReportError(enum_pos, "'%s' is already defined", enum_name->ToCString());
+  }
+  Class& cls = Class::Handle(I);
+  cls = Class::New(*enum_name, script_, enum_pos);
+  cls.set_library(library_);
+  library_.AddClass(cls);
+  cls.set_is_synthesized_class();
+  cls.set_is_enum_class();
+  if (metadata_pos >= 0) {
+    library_.AddClassMetadata(cls, toplevel_class, metadata_pos);
+  }
+  cls.set_super_type(Type::Handle(I, Type::ObjectType()));
+  pending_classes.Add(cls, Heap::kOld);
+}
+
+
 void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                                    const Class& toplevel_class,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
@@ skipping 222 matching lines @@
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     Error& error = Error::Handle(I);
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
 
+void Parser::ParseEnumDefinition(const Class& cls) {
+  TRACE_PARSER("ParseEnumDefinition");
+  CompilerStats::num_classes_compiled++;
+
+  const String& enum_name = String::Handle(I, cls.Name());
+  ClassDesc enum_members(cls, enum_name, false, cls.token_pos());
+
+  // Add instance field 'final int index'.
+  Field& index_field = Field::ZoneHandle(I);
+  const Type& int_type = Type::Handle(I, Type::IntType());
+  const Type& dynamic_type = Type::Handle(Type::DynamicType());
+  index_field = Field::New(Symbols::Index(),
+                           false,  // Not static.
+                           true,  // Field is final.
+                           false,  // Not const.
+                           false,  // Not synthetic.
+                           cls,
+                           cls.token_pos());
+  index_field.set_type(int_type);
+  enum_members.AddField(index_field);
+
+  // Add implicit getter for index field.
+  const String& getter_name =
+      String::Handle(I, Field::GetterSymbol(Symbols::Index()));
+  Function& getter = Function::Handle(I);
+  getter = Function::New(getter_name,
+                         RawFunction::kImplicitGetter,
+                         /* is_static = */ false,
+                         /* is_const = */ true,
+                         /* is_abstract = */ false,
+                         /* is_external = */ false,
+                         /* is_native = */ false,
+                         cls,
+                         cls.token_pos());
+  getter.set_result_type(int_type);
+  ParamList params;
+  params.AddReceiver(&dynamic_type, cls.token_pos());
+  AddFormalParamsToFunction(&params, getter);
+  enum_members.AddFunction(getter);
+
+  GrowableObjectArray& enum_names = GrowableObjectArray::Handle(I,
+      GrowableObjectArray::New(8, Heap::kOld));
+  const String& name_prefix =
+      String::Handle(String::Concat(enum_name, Symbols::Dot()));
+
+  ASSERT(IsIdentifier());
+  ASSERT(CurrentLiteral()->raw() == cls.Name());
+
+  ConsumeToken();  // Enum type name.
+  ExpectToken(Token::kLBRACE);
+  Field& enum_value = Field::Handle(I);
+  String& enum_value_name = String::Handle(I);
+  intptr_t i = 0;
+  GrowableArray<String*> declared_names(8);
+
+  while (IsIdentifier()) {
+    String* enum_ident = CurrentLiteral();
+
+    // Check for name conflicts.
+    if (enum_ident->raw() == cls.Name()) {
+      ReportError("enum identifier '%s' cannot be equal to enum type name",
+          CurrentLiteral()->ToCString());
+    } else if (enum_ident->raw() == Symbols::Index().raw()) {
+      ReportError("enum identifier conflicts with "
+                  "implicit instance field 'index'");
+    } else if (enum_ident->raw() == Symbols::Values().raw()) {
+      ReportError("enum identifier conflicts with "
+                  "implicit static field 'values'");
+    } else if (enum_ident->raw() == Symbols::toString().raw()) {
+      ReportError("enum identifier conflicts with "
+                  "implicit instance method 'toString()'");
+    }
+    for (intptr_t i = 0; i < declared_names.length(); i++) {
+      if (enum_ident->Equals(*declared_names[i])) {
+        ReportError("Duplicate name '%s' in enum definition '%s'",
+                    enum_ident->ToCString(),
+                    enum_name.ToCString());
+      }
+    }
+    declared_names.Add(enum_ident);
+
+    // Create the static const field for the enumeration value.
+    enum_value = Field::New(*enum_ident,
+                            /* is_static = */ true,
+                            /* is_final = */ true,
+                            /* is_const = */ true,
+                            /* is_synthetic = */ false,
+                            cls,
+                            cls.token_pos());
+    enum_value.set_type(dynamic_type);
+    enum_value.set_has_initializer(false);
+    enum_members.AddField(enum_value);
+    // Initialize the field with the ordinal value. It will be patched
+    // later with the enum constant instance.
+    const Smi& ordinal_value = Smi::Handle(I, Smi::New(i));
+    enum_value.set_value(ordinal_value);
+    enum_value.RecordStore(ordinal_value);
+    i++;
+
+    // For the user-visible name of the enumeration value, we need to
+    // unmangle private names.
+    if (enum_ident->CharAt(0) == '_') {
+      *enum_ident = String::IdentifierPrettyName(*enum_ident);
+    }
+    enum_value_name = Symbols::FromConcat(name_prefix, *enum_ident);
+    enum_names.Add(enum_value_name, Heap::kOld);
+
+    ConsumeToken();  // Enum value name.
+    if (CurrentToken() == Token::kCOMMA) {
+      ConsumeToken();
+    }
+  }
+  ExpectToken(Token::kRBRACE);
+
+  const Class& helper_class =
+      Class::Handle(I, Library::LookupCoreClass(Symbols::_EnumHelper()));
+  ASSERT(!helper_class.IsNull());
+
+  // Add static field 'const List values'.
+  Field& values_field = Field::ZoneHandle(I);
+  values_field = Field::New(Symbols::Values(),
+                            /* is_static = */ true,
+                            /* is_final = */ true,
+                            /* is_const = */ true,
+                            /* is_synthetic = */ false,
+                            cls,
+                            cls.token_pos());
+  values_field.set_type(Type::Handle(I, Type::ArrayType()));
+  enum_members.AddField(values_field);
+
+  // Allocate the immutable array containing the enumeration values.
+  // The actual enum instance values will be patched in later.
+  const Array& values_array = Array::Handle(I, Array::New(i, Heap::kOld));
+  values_field.set_value(values_array);
+  values_field.RecordStore(values_array);
+
+  // Create a static field that contains the list of enumeration names.
+  // Clone the _enum_names field from the helper class.
+  Field& names_field = Field::Handle(I,
+      helper_class.LookupStaticField(Symbols::_EnumNames()));
+  ASSERT(!names_field.IsNull());
+  names_field = names_field.Clone(cls);
+  enum_members.AddField(names_field);
+  const Array& names_array = Array::Handle(Array::MakeArray(enum_names));
+  names_field.set_value(names_array);
+  names_field.RecordStore(names_array);
+
+  // Clone the toString() function from the helper class.
+  Function& to_string_func = Function::Handle(I,
+      helper_class.LookupDynamicFunctionAllowPrivate(Symbols::toString()));
+  ASSERT(!to_string_func.IsNull());
+  to_string_func = to_string_func.Clone(cls);
+  to_string_func.set_is_visible(false);
+  enum_members.AddFunction(to_string_func);
+
+  cls.AddFields(enum_members.fields());
+  const Array& functions =
+      Array::Handle(I, Array::MakeArray(enum_members.functions()));
+  cls.SetFunctions(functions);
+}
+
+
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(I, cls.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   ctor_name = Symbols::New(ctor_name);
   // To indicate that this is an implicit constructor, we set the
   // token position and end token position of the function
   // to the token position of the class.
   Function& ctor = Function::Handle(I,
@@ skipping 1162 matching lines @@
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   const Class& cls = Class::Handle(I);
   while (true) {
     set_current_class(cls);  // No current class.
     intptr_t metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
+    } else if (CurrentToken() == Token::kENUM) {
+      ParseEnumDeclaration(pending_classes, toplevel_class, metadata_pos);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes, toplevel_class, metadata_pos);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
     } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDeclaration(pending_classes, toplevel_class, metadata_pos);
@@ skipping 5540 matching lines @@
     type = ClassFinalizer::NewFinalizedMalformedType(
         Error::Handle(I),  // No previous error.
         script_,
         type_pos,
         "%s'%s' cannot be instantiated",
         type.IsTypeParameter() ? "type parameter " : "",
         type.IsTypeParameter() ?
             String::Handle(I, type.UserVisibleName()).ToCString() :
             "dynamic");
   }
+  // Attempting to instantiate an enum type is a compile-time error.
+  Class& type_class = Class::Handle(I, type.type_class());
+  if (type_class.is_enum_class()) {
+    ReportError(new_pos, "enum type '%s' can not be instantiated",
+                String::Handle(I, type_class.Name()).ToCString());
+  }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that we tell ParseType() above not to
   // consume it as part of a misinterpreted qualified identifier. Only a
   // valid library prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   CheckToken(Token::kLPAREN);
   intptr_t call_pos = TokenPos();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // Parsing is complete, so we can return a throw in case of a malformed or
   // malbounded type or report a compile-time error if the constructor is const.
   if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
       const Error& error = Error::Handle(I, type.error());
       ReportError(error);
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
-  Class& type_class = Class::Handle(I, type.type_class());
   String& type_class_name = String::Handle(I, type_class.Name());
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(I, type.arguments());
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   // An additional type check of the result of a redirecting factory may be
@@ skipping 865 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart