Support covariant keyword in the VM parser

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/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 655 matching lines @@
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(TokenPosition::kNoSource),
         name(NULL),
         default_value(NULL),
         metadata(NULL),
         var(NULL),
         is_final(false),
         is_field_initializer(false),
-        has_explicit_type(false) {}
+        has_explicit_type(false),
+        is_covariant(false) {}
   const AbstractType* type;
   TokenPosition name_pos;
   const String* name;
   const Instance* default_value;  // NULL if not an optional parameter.
   const Object* metadata;  // NULL if no metadata or metadata not evaluated.
   LocalVariable* var;      // Scope variable allocated for this parameter.
   bool is_final;
   bool is_field_initializer;
   bool has_explicit_type;
+  bool is_covariant;
 };
 
 
 struct ParamList {
   ParamList() { Clear(); }
 
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_optional_positional_parameters = false;
     has_optional_named_parameters = false;
     has_explicit_default_values = false;
     has_field_initializer = false;
+    has_covariant = false;
     implicitly_final = false;
     skipped = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(TokenPosition name_pos,
                          const String* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
@@ skipping 41 matching lines @@
   }
 
   void SetImplicitlyFinal() { implicitly_final = true; }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_optional_positional_parameters;
   bool has_optional_named_parameters;
   bool has_explicit_default_values;
   bool has_field_initializer;
+  bool has_covariant;
   bool implicitly_final;
   bool skipped;
   ZoneGrowableArray<ParamDesc>* parameters;
 };
 
 
 struct MemberDesc {
   MemberDesc() { Clear(); }
 
   void Clear() {
     has_abstract = false;
     has_external = false;
+    has_covariant = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
     has_operator = false;
     has_native = false;
     metadata_pos = TokenPosition::kNoSource;
     operator_token = Token::kILLEGAL;
     type = NULL;
@@ skipping 27 matching lines @@
     } else if (IsGetter()) {
       return "getter";
     } else if (IsSetter()) {
       return "setter";
     }
     return "method";
   }
   String* DictName() const { return (dict_name != NULL) ? dict_name : name; }
   bool has_abstract;
   bool has_external;
+  bool has_covariant;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
   bool has_native;
   TokenPosition metadata_pos;
   Token::Kind operator_token;
   const AbstractType* type;
@@ skipping 1110 matching lines @@
   bool var_seen = false;
   bool final_seen = false;
   bool this_seen = false;
 
   if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
     parameter.metadata = &Array::ZoneHandle(Z, EvaluateMetadata());
   } else {
     SkipMetadata();
   }
 
+  if (CurrentToken() == Token::kCOVARIANT &&
+      (LookaheadToken(1) == Token::kFINAL || LookaheadToken(1) == Token::kVAR ||
+       Token::IsIdentifier(LookaheadToken(1)))) {
+    parameter.is_covariant = true;
+    ConsumeToken();
+  }
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     final_seen = true;
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
     // The parameter type is the 'dynamic' type.
     // If this is an initializing formal, its type will be set to the type of
     // the respective field when the constructor is fully parsed.
@@ skipping 197 matching lines @@
     }
   }
   if (parameter.type->IsVoidType()) {
     ReportError("parameter '%s' may not be 'void'",
                 parameter.name->ToCString());
   }
   if (params->implicitly_final) {
     parameter.is_final = true;
   }
   params->parameters->Add(parameter);
+  if (parameter.is_covariant) {
+    params->has_covariant = true;
+  }
 }
 
 
 // Parses a sequence of normal or optional formal parameters.
 void Parser::ParseFormalParameters(bool allow_explicit_default_values,
                                    bool evaluate_metadata,
                                    ParamList* params) {
   TRACE_PARSER("ParseFormalParameters");
   // Optional parameter lists cannot be empty.
   // The completely empty parameter list is handled before getting here.
@@ skipping 1491 matching lines @@
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   // We are at the beginning of the formal parameters list.
   ASSERT(CurrentToken() == Token::kLPAREN || CurrentToken() == Token::kLT ||
          method->IsGetter());
   ASSERT(method->type != NULL);  // May still be unresolved.
   ASSERT(current_member_ == method);
 
+  if (method->has_covariant) {
+    ReportError(method->name_pos,
+                "methods and constructors cannot be declared covariant");
+  }
   if (method->has_var) {
     ReportError(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ReportError(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
     ReportError(method->name_pos, "static method '%s' cannot be abstract",
                 method->name->ToCString());
   }
@@ skipping 347 matching lines @@
   // 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.IsReal());
   ASSERT(current_member_ == field);
   // All const fields are also final.
   ASSERT(!field->has_const || field->has_final);
 
+  if (field->has_covariant) {
+    if (field->has_static) {
+      ReportError("static fields cannot be declared covariant");
+    } else if (field->has_final) {
+      ReportError("final fields cannot be declared covariant");
+    }
+  }
   if (field->has_abstract) {
     ReportError("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_external) {
     ReportError("keyword 'external' not allowed in field declaration");
   }
   if (field->has_factory) {
     ReportError("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
@@ skipping 191 matching lines @@
   if ((CurrentToken() == Token::kEXTERNAL) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_external = true;
   }
   if ((CurrentToken() == Token::kSTATIC) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_static = true;
   }
+  if (CurrentToken() == Token::kCOVARIANT) {
+    ConsumeToken();
+    member.has_covariant = true;
+  }
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     member.has_const = true;
   } else if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     member.has_final = true;
   }
   if (CurrentToken() == Token::kVAR) {
     if (member.has_const) {
       ReportError("identifier expected after 'const'");
@@ skipping 3041 matching lines @@
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     func.SetParameterTypeAt(i, *param_desc.type);
     func.SetParameterNameAt(i, *param_desc.name);
     if (param_desc.is_field_initializer && !func.IsGenerativeConstructor()) {
       // Redirecting constructors are detected later in ParseConstructor.
       ReportError(param_desc.name_pos,
                   "only generative constructors may have "
                   "initializing formal parameters");
     }
+    if (param_desc.is_covariant) {
+      if (!func.IsDynamicFunction(true)) {
+        ReportError(param_desc.name_pos,
+                    "only instance functions may have "
+                    "covariant parameters");
+      }
+    }
   }
 }
 
 
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
@@ skipping 7298 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME