Consolidate a few fields in RawFunction using bitfields.

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 1063 matching lines @@
       ParamList func_params;
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
+                        /* is_abstract = */ false,
                         parameter.name_pos));
       signature_function.set_owner(current_class());
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
       Class& signature_class = Class::ZoneHandle(
           library_.LookupLocalClass(signature));
@@ skipping 1361 matching lines @@
     } else {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
   }
 
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
-  } else if (method->has_abstract) {
-    function_kind = RawFunction::kAbstract;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kFunction;
   }
   Function& func = Function::Handle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
+                    method->has_abstract,
                     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);
 }
 
@@ skipping 52 matching lines @@
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(Instance::Handle(Object::sentinel()));
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
                              field->has_static, field->has_final,
+                             /* is_abstract */ false,
                              field->name_pos);
       getter.set_result_type(*field->type);
       members->AddFunction(getter);
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static, field->has_final,
+                             /* is_abstract */ false,
                              field->name_pos);
       ParamList params;
       params.AddReceiver(TokenPos());
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static, field->has_final,
+                               /* is_abstract */ false,
                                field->name_pos);
         ParamList params;
         params.AddReceiver(TokenPos());
         params.AddFinalParameter(TokenPos(), "value", field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
     }
 
@@ skipping 347 matching lines @@
         String::Concat(class_desc->class_name(),
                        String::Handle(String::NewSymbol("."))));
     ctor_name = String::NewSymbol(ctor_name);
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
     Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
+                      /* is_abstract = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(TokenPos());
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
         TokenPos(),
         kPhaseParameterName,
         &Type::ZoneHandle(Type::DynamicType()));
 
@@ skipping 98 matching lines @@
   }
   ParamList func_params;
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
+                    /* is_abstract = */ false,
                     alias_name_pos));
   signature_function.set_owner(alias_owner);
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
   const String& signature = String::Handle(signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
@@ skipping 374 matching lines @@
   }
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
+  const bool is_abstract = false;
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
                                 ClassFinalizer::kIgnore));
   Field& field = Field::Handle();
   Function& getter = Function::Handle();
   while (true) {
     const intptr_t name_pos = TokenPos();
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
@@ skipping 15 matching lines @@
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       SkipExpr();
       field.set_value(Instance::Handle(Object::sentinel()));
       // Create a static const getter.
       String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
       getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                             is_static, is_final, name_pos);
+                             is_static, is_final, is_abstract, name_pos);
       getter.set_result_type(type);
       top_level->functions.Add(getter);
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
@@ skipping 53 matching lines @@
     SkipExpr();
     ExpectSemicolon();
     function_end_pos = TokenPos();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(func_name, RawFunction::kFunction,
-                    is_static, false, function_pos));
+                    is_static, false, false, function_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelAccessor");
@@ skipping 61 matching lines @@
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(accessor_name,
                     is_getter? RawFunction::kGetterFunction :
                                RawFunction::kSetterFunction,
-                    is_static, false, accessor_pos));
+                    is_static, false, false, accessor_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, accessor_name);
 }
 
 
 void Parser::ParseLibraryName() {
   TRACE_PARSER("ParseLibraryName");
   if ((script_.kind() == RawScript::kLibrary) &&
@@ skipping 5006 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart