Assign ids to incoming arguments (to be used in checked mode).

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 94 matching lines @@
   UnhandledException& excp = UnhandledException::Handle();
   excp ^= obj.raw();
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
+void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
+  ASSERT(node_sequence_ == NULL);
+  ASSERT(node_sequence != NULL);
+  node_sequence_ = node_sequence;
+  const int num_fixed_params = function().num_fixed_parameters();
+  const int num_opt_params = function().num_optional_parameters();
+  // Allocated ids for parameters.
+  intptr_t parameter_id = AstNode::kNoId;
+  for (intptr_t i = 0; i < num_fixed_params + num_opt_params; i++) {
+    parameter_id = AstNode::GetNextId();
+    if (i == 0) {
+      node_sequence_->set_first_parameter_id(parameter_id);
+    }
+  }
+  node_sequence_->set_last_parameter_id(parameter_id);

[regis, 2012/04/18 23:59:13]

It is strange to call set_last_parameter_id, but not set_first_parameter_id,
when the function has no parameters.
How about storing the number of parameters instead of the last_parameter_id? But
isn't that number available without storing it? 

[srdjan, 2012/04/19 00:04:20]

Discussed off-line: last parameter id is set to kNoId (initial value of
parameter_id) if function has not parameters.

+}
+
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const int fixed_parameter_count = function().num_fixed_parameters();
   const int optional_parameter_count = function().num_optional_parameters();
   const int parameter_count = fixed_parameter_count + optional_parameter_count;
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   if (optional_parameter_count == 0) {
     // Parameter i will be at fp[1 + parameter_count - i] and local variable
     // j will be at fp[-1 - j].
@@ skipping 534 matching lines @@
       node_sequence = parser.ParseStaticConstGetter(func);
       break;
     default:
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(parser.token_index_));
   }
-  parsed_function->set_node_sequence(node_sequence);
+  parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
     const bool kTestOnly = true;
     LocalVariable* receiver =
         parser.LookupReceiver(node_sequence->scope(),
                               kTestOnly);
@@ skipping 7707 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart