Fix CompilerStats info

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 426 matching lines @@
 }
 
 
 void Parser::set_current_class(const Class& value) {
   current_class_ = value.raw();
 }
 
 
 void Parser::SetPosition(intptr_t position) {
   if (position < TokenPos() && position != 0) {
-    CompilerStats::num_tokens_rewind += (TokenPos() - position);
+    INC_STAT(I, num_tokens_rewind, (TokenPos() - position));
   }
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
-  TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+  TimerScope timer(FLAG_compiler_stats, &CSTAT_TIMER(parser_timer));
   VMTagScope tagScope(isolate, VMTag::kCompileTopLevelTagId);
   Parser parser(script, library, 0);
   parser.ParseTopLevel();
 }
 
 
 void Parser::ComputeCurrentToken() {
   ASSERT(token_kind_ == Token::kILLEGAL);
   token_kind_ = tokens_iterator_.CurrentTokenKind();
   if (token_kind_ == Token::kERROR) {
     ReportError(TokenPos(), "%s", CurrentLiteral()->ToCString());
   }
 }
 
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
-  CompilerStats::num_tokens_lookahead++;
-  CompilerStats::num_token_checks++;
+  INC_STAT(I, num_tokens_lookahead, 1);
+  INC_STAT(I, num_token_checks, 1);
   return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
 
 String* Parser::CurrentLiteral() const {
   String& result =
       String::ZoneHandle(Z, tokens_iterator_.CurrentLiteral());
   return &result;
 }
 
@@ skipping 280 matching lines @@
       functions(GrowableObjectArray::Handle(GrowableObjectArray::New())) { }
 
   GrowableObjectArray& fields;
   GrowableObjectArray& functions;
 };
 
 
 void Parser::ParseClass(const Class& cls) {
   if (!cls.is_synthesized_class()) {
     Isolate* isolate = Isolate::Current();
-    TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+    TimerScope timer(FLAG_compiler_stats, &CSTAT_TIMER(parser_timer));
     ASSERT(isolate->long_jump_base()->IsSafeToJump());
     const Script& script = Script::Handle(isolate, cls.script());
     const Library& lib = Library::Handle(isolate, cls.library());
     Parser parser(script, lib, cls.token_pos());
     parser.ParseClassDefinition(cls);
   } else if (cls.is_enum_class()) {
     Isolate* isolate = Isolate::Current();
-    TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
+    TimerScope timer(FLAG_compiler_stats, &CSTAT_TIMER(parser_timer));
     ASSERT(isolate->long_jump_base()->IsSafeToJump());
     const Script& script = Script::Handle(isolate, cls.script());
     const Library& lib = Library::Handle(isolate, cls.library());
     Parser parser(script, lib, cls.token_pos());
     parser.ParseEnumDefinition(cls);
   }
 }
 
 
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
@@ skipping 40 matching lines @@
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   Isolate* isolate = parsed_function->isolate();
   Zone* zone = parsed_function->zone();
-  TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
-  CompilerStats::num_functions_compiled++;
+  TimerScope timer(FLAG_compiler_stats, &CSTAT_TIMER(parser_timer));
+  INC_STAT(isolate, num_functions_compiled, 1);
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Script& script = Script::Handle(zone, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::ZoneHandle(zone, Array::null());
   switch (func.kind()) {
     case RawFunction::kClosureFunction:
       if (func.IsImplicitClosureFunction()) {
@@ skipping 17 matching lines @@
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kImplicitStaticFinalGetter:
       node_sequence = parser.ParseStaticFinalGetter(func);
-      CompilerStats::num_implicit_final_getters++;
+      INC_STAT(isolate, num_implicit_final_getters, 1);
       break;
     case RawFunction::kMethodExtractor:
       node_sequence = parser.ParseMethodExtractor(func);
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       node_sequence =
           parser.ParseNoSuchMethodDispatcher(func, &default_parameter_values);
       break;
     case RawFunction::kInvokeFieldDispatcher:
       node_sequence =
@@ skipping 3589 matching lines @@
   } else {
     CheckToken(Token::kLBRACE);
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   }
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
-  CompilerStats::num_classes_compiled++;
+  INC_STAT(I, num_classes_compiled, 1);
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(Z, cls.Name());
   SkipMetadata();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
   } else if (CurrentToken() == Token::kABSTRACT) {
     ConsumeToken();
@@ skipping 39 matching lines @@
     Error& error = Error::Handle(Z);
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
 
 void Parser::ParseEnumDefinition(const Class& cls) {
   TRACE_PARSER("ParseEnumDefinition");
-  CompilerStats::num_classes_compiled++;
+  INC_STAT(I, num_classes_compiled, 1);
 
   SkipMetadata();
   ExpectToken(Token::kENUM);
 
   const String& enum_name = String::Handle(Z, cls.Name());
   ClassDesc enum_members(cls, enum_name, false, cls.token_pos());
 
   // Add instance field 'final int index'.
   Field& index_field = Field::ZoneHandle(Z);
   const Type& int_type = Type::Handle(Z, Type::IntType());
@@ skipping 8912 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart