Implement argument definition test in the vm.

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "vm/ast.h"
@@ skipping 50 matching lines @@
   void set_default_parameter_values(const Array& default_parameter_values) {
     default_parameter_values_ = default_parameter_values.raw();
   }
 
   LocalVariable* saved_context_var() const { return saved_context_var_; }
   void set_saved_context_var(LocalVariable* saved_context_var) {
     ASSERT(saved_context_var != NULL);
     saved_context_var_ = saved_context_var;
   }
 
+  // Returns NULL if this function does not save the arguments descriptor on
+  // entry.
+  LocalVariable* GetSavedArgumentsDescriptorVar() const;
+
   LocalVariable* expression_temp_var() const {
     ASSERT(has_expression_temp_var());
     return expression_temp_var_;
   }
   void set_expression_temp_var(LocalVariable* value) {
     ASSERT(!has_expression_temp_var());
     expression_temp_var_ = value;
   }
   bool has_expression_temp_var() const {
     return expression_temp_var_ != NULL;
@@ skipping 371 matching lines @@
   AstNode* ParseStringLiteral();
   String* ParseImportStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseListLiteral(intptr_t type_pos,
                             bool is_const,
                             const AbstractTypeArguments& type_arguments);
   AstNode* ParseMapLiteral(intptr_t type_pos,
                            bool is_const,
                            const AbstractTypeArguments& type_arguments);
   AstNode* ParseNewOperator();
+  AstNode* ParseArgumentDefinitionTest();
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
                            intptr_t ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver, const String& method_name);
   AstNode* ParseClosureCall(AstNode* closure);
   AstNode* GenerateStaticFieldLookup(const Field& field,
                                      intptr_t ident_pos);
   AstNode* ParseStaticFieldAccess(const Class& cls,
                                   const String& field_name,
                                   intptr_t ident_pos,
                                   bool consume_cascades);
 
   LocalVariable* LookupLocalScope(const String& ident);
+  bool IsFormalParameter(const String& ident,
+                         Function* owner_function,
+                         LocalScope** owner_scope,
+                         intptr_t* local_index);
   void CheckInstanceFieldAccess(intptr_t field_pos, const String& field_name);
   RawClass* TypeParametersScopeClass() const;
   const Type* ReceiverType(intptr_t type_pos) const;
   bool IsInstantiatorRequired() const;
   bool IsDefinedInLexicalScope(const String& ident);
   bool ResolveIdentInLocalScope(intptr_t ident_pos,
                                 const String &ident,
                                 AstNode** node);
   static const bool kResolveLocally = true;
   static const bool kResolveIncludingImports = false;
@@ skipping 105 matching lines @@
 
   // Allocate temporary only once per function.
   LocalVariable* expression_temp_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_