Support const modifier in fields, variables

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 739 matching lines @@
   // Static const fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-  if (field.is_const()) {
+  // TODO(hausner): Remove is_final check below once we support
+  // non-const finals.
+  if (field.is_const() || field.is_final()) {
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "initializer must be a compile time constant");
     }
     ReturnNode* return_node = new ReturnNode(TokenPos(), expr);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
     // if (field.value === transition_sentinel) {
@@ skipping 1702 matching lines @@
 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);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
+  ASSERT(!field->has_const || field->has_final);
 
-  if (field->has_const) {
-    ErrorMsg("keyword 'const' not allowed in field declaration");
-  }
   if (field->has_abstract) {
     ErrorMsg("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (members->FieldNameExists(*field->name)) {
     ErrorMsg(field->name_pos,
              "'%s' field/method already defined\n", field->name->ToCString());
   }
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     if (has_initializer) {
       ConsumeToken();
       // For static final fields, the initialization expression
       // will be parsed through the kConstImplicitGetter method
       // invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
       SkipExpr();
     } else {
-      if (field->has_static && field->has_final) {
+      if (field->has_const || (field->has_static && field->has_final)) {
         ErrorMsg(field->name_pos,
-                 "static final field '%s' must have an initializer expression",
+                 "%s%s field '%s' must have an initializer expression",
+                 field->has_static ? "static " : "",
+                 field->has_const ? "const" : "final",
                  field->name->ToCString());
       }
     }
 
     // Create the field object.
+    // TODO(hausner): For now, all static final fields are constant. Remove
+    // this when lazy init of static variables is implemented.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
+                             field->has_const || field->has_final,
                              field->name_pos);
     class_field.set_type(*field->type);
     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));
@@ skipping 259 matching lines @@
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ParseMethodOrConstructor(members, &member);
     if (operator_token != Token::kILLEGAL) {
       CheckOperatorArity(member, operator_token);
     }
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
+    if (member.has_const) {
+      // const fields are implicitly final.
+      member.has_final = true;
+    }
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Type::ZoneHandle(Type::DynamicType());
       } else {
-        ErrorMsg("missing 'var', 'final' or type in field declaration");
+        ErrorMsg("missing 'var', 'final', 'const' or type"
+                 " in field declaration");
       }
     }
     if (members->is_interface() && member.has_static && !member.has_final) {
       ErrorMsg("static non-final fields are not allowed in interfaces");
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
@@ skipping 609 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_const = (CurrentToken() == Token::kCONST);
   const bool is_static = true;
-  const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
-                                ClassFinalizer::kIgnore));
+  const AbstractType& type =
+      AbstractType::ZoneHandle(ParseConstFinalVarOrType(
+          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()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
-    field = Field::New(var_name, is_static, is_final, name_pos);
+    field = Field::New(var_name, is_static, is_final, is_const, name_pos);
     field.set_type(type);
     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);
       getter.set_result_type(type);
       top_level->functions.Add(getter);
-    } else if (is_final) {
-      ErrorMsg(name_pos, "missing initializer for final variable");
+    } else if (is_final || is_const) {
+      ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
@@ skipping 572 matching lines @@
 
 
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
   return new InstanceGetterNode(TokenPos(), object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
-AstNode* Parser::ParseVariableDeclaration(
-    const AbstractType& type, bool is_final) {
+AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
+                                          bool is_final,
+                                          bool is_const) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
-    AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
+    AstNode* expr = ParseExpr(is_const, kConsumeCascades);
     initialization = new StoreLocalNode(assign_pos, *variable, expr);
-  } else if (is_final) {
-    ErrorMsg(ident_pos, "missing initialization of 'final' variable");
+  } else if (is_final || is_const) {
+    ErrorMsg(ident_pos,
+    "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
     initialization = new StoreLocalNode(ident_pos, *variable, null_expr);
   }
-  // Add variable to cope after parsing the initalizer expression.
+  // Add variable to scope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     ErrorMsg(ident_pos, "identifier '%s' already defined",
              variable->name().ToCString());
   }
-  if (is_final) {
+  if (is_final || is_const) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
-// Parses ('var' | 'final' [type] | type).
-// The presence of 'final' must be detected and remembered before the call.
-// If a type is parsed, it may be resolved and finalized according to the given
-// type finalization mode.
-RawAbstractType* Parser::ParseFinalVarOrType(
+// Parses ('var' | 'final' [type] | 'const' [type] | type).
+// The presence of 'final' or 'const' must be detected and remembered
+// before the call. If a type is parsed, it may be resolved and finalized
+// according to the given type finalization mode.
+RawAbstractType* Parser::ParseConstFinalVarOrType(
     ClassFinalizer::FinalizationKind finalization) {
-  TRACE_PARSER("ParseFinalVarOrType");
+  TRACE_PARSER("ParseConstFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   bool type_is_optional = false;
-  if (CurrentToken() == Token::kFINAL) {
+  if ((CurrentToken() == Token::kFINAL) || (CurrentToken() == Token::kCONST)) {
     ConsumeToken();
     type_is_optional = true;
   }
   if (CurrentToken() != Token::kIDENT) {
     if (type_is_optional) {
       return Type::DynamicType();
     } else {
       ErrorMsg("type name expected");
     }
   }
@@ skipping 11 matching lines @@
   return ParseType(finalization);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
-  const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
+  bool is_const = (CurrentToken() == Token::kCONST);
+  const AbstractType& type = AbstractType::ZoneHandle(ParseConstFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                 ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
-  AstNode* initializers = ParseVariableDeclaration(type, is_final);
+  AstNode* initializers = ParseVariableDeclaration(type, is_final, is_const);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
       ErrorMsg("identifier expected after comma");
     }
     // We have a second initializer. Allocate a sequence node now.
     // The sequence does not own the current scope. Set its own scope to NULL.
     SequenceNode* sequence = NodeAsSequenceNode(initializers->token_pos(),
                                                 initializers,
                                                 NULL);
-    sequence->Add(ParseVariableDeclaration(type, is_final));
+    sequence->Add(ParseVariableDeclaration(type, is_final, is_const));
     initializers = sequence;
   }
   return initializers;
 }
 
 
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
@@ skipping 252 matching lines @@
     return true;
   } else if (CurrentToken() == Token::kIDENT) {
     return TryParseOptionalType();
   }
   return false;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
 // a variable declaration. Returns true if we detect the token pattern:
-// ('var' | 'final' | type ident (';' | '=' | ','))
+//     'var'
+//   | 'final'
+//   | const [type] ident (';' | '=' | ',')
+//   | type ident (';' | '=' | ',')
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) ||
       (CurrentToken() == Token::kFINAL)) {
     return true;
   }
-  if (CurrentToken() != Token::kIDENT) {
-    // Not a legal type identifier.
+  if ((CurrentToken() != Token::kIDENT) && (CurrentToken() != Token::kCONST)) {
+    // Not a legal type identifier or const keyword
     return false;
   }
   const intptr_t saved_pos = TokenPos();
   bool is_var_decl = false;
-  if (TryParseOptionalType()) {
-    if (IsIdentifier()) {
+  bool have_type = false;
+  if (CurrentToken() == Token::kCONST) {
+    ConsumeToken();
+    have_type = true;  // Type is Dynamic.
+  }
+  if (IsIdentifier()) {  // Type or variable name.
+    Token::Kind follower = LookaheadToken(1);
+    if ((follower == Token::kLT) ||  // Parameterized type.
+        (follower == Token::kPERIOD) ||  // Qualified class name of type.
+        Token::IsIdentifier(follower)) {  // Variable name following a type.
+      // We see the beginning of something that could be a type.
+      const intptr_t type_pos = TokenPos();
+      if (TryParseOptionalType()) {
+        have_type = true;
+      } else {
+        SetPosition(type_pos);
+      }
+    }
+    if (have_type && IsIdentifier()) {
       ConsumeToken();
       if ((CurrentToken() == Token::kSEMICOLON) ||
           (CurrentToken() == Token::kCOMMA) ||
           (CurrentToken() == Token::kASSIGN)) {
         is_var_decl = true;
       }
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
@@ skipping 403 matching lines @@
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
+  if (CurrentToken() == Token::kCONST) {
+    ErrorMsg("Loop variable cannot be 'const'");
+  }
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
-    const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
-                                ClassFinalizer::kIgnore));
+    const AbstractType& type =
+        AbstractType::ZoneHandle(ParseConstFinalVarOrType(
+            FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
+                                      ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
@@ skipping 230 matching lines @@
 };
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   // The type of the catch parameter must always be resolved, even in unchecked
   // mode.
+  if (CurrentToken() == Token::kCONST) {
+    ErrorMsg("Catch parameter cannot be 'const'");
+  }
   catch_param->type = &AbstractType::ZoneHandle(
-      ParseFinalVarOrType(ClassFinalizer::kCanonicalizeWellFormed));
+      ParseConstFinalVarOrType(ClassFinalizer::kCanonicalizeWellFormed));
   catch_param->token_pos = TokenPos();
   catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
@@ skipping 1375 matching lines @@
                                            intptr_t ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
   // The field is initialized.
-  if (field.is_const()) {
+  // TODO(hausner): Remove the is_final check when we support non-const
+  // final static variables.
+  if (field.is_const() || field.is_final()) {
     ASSERT(field.value() != Object::sentinel());
     ASSERT(field.value() != Object::transition_sentinel());
     return new LiteralNode(ident_pos, Instance::ZoneHandle(field.value()));
   }
   // Access the field directly.
   return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
@@ skipping 437 matching lines @@
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
-    if (field.is_const()) {
+    // TODO(hausner): Remove the check for is_final() once we support
+    // non-const final fields.
+    if (field.is_const() || field.is_final()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                String::Handle(field.name()).ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new StaticGetterNode(TokenPos(),
                                   NULL,
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   } else if (value.raw() == Object::sentinel()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
-    if (field.is_const()) {
+    // TODO(hausner): Remove the check for is_final() once we support
+    // non-const final fields.
+    if (field.is_const() || field.is_final()) {
       field.set_value(Instance::Handle(Object::transition_sentinel()));
       const String& field_name = String::Handle(field.name());
       const String& getter_name =
           String::Handle(Field::GetterName(field_name));
       const Class& cls = Class::Handle(field.owner());
       GrowableArray<const Object*> arguments;  // no arguments.
       const int kNumArguments = 0;  // no arguments.
       const Array& kNoArgumentNames = Array::Handle();
       const Function& func =
           Function::Handle(Resolver::ResolveStatic(cls,
@@ skipping 1159 matching lines @@
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
         expr = ParseExpr(kAllowConst, kConsumeCascades);
         ExpectToken(Token::kINTERPOL_END);
       }
       // Check if this interpolated string is still considered a compile time
       // constant. If it is we need to evaluate if the current string part is
-      // a constant or not.
+      // a constant or not. Only stings, numbers, booleans and null values
+      // are allowed in compile time const interpolations.
       if (is_compiletime_const) {
         const Object* const_expr = expr->EvalConstExpr();
-        if (const_expr != NULL) {
+        if ((const_expr != NULL) &&
+            (const_expr->IsNumber() ||
+            const_expr->IsString() ||
+            const_expr->IsBool() ||
+            const_expr->IsNull())) {
           // Change expr into a literal.
           expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr));
         } else {
           is_compiletime_const = false;
         }
       }
       values->AddElement(expr);
     }
   }
   if (is_compiletime_const) {
@@ skipping 475 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart