Improve compilation times for swarm application startup.

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 1896 matching lines @@
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
   ASSERT(IsIdentifier());
   if (!is_top_level_) {
+    AstNode* var_or_field = NULL;
     bool is_local_ident = ResolveIdentInLocalScope(token_index_,
                                                    *CurrentLiteral(),
-                                                   NULL);
+                                                   &var_or_field);
     qual_ident->ident_pos = token_index_;
     qual_ident->ident = CurrentLiteral();
     qual_ident->lib_prefix = NULL;
     qual_ident->qualifier = NULL;
     qual_ident->is_local_scope_ident = is_local_ident;
     ConsumeToken();
     if (!is_local_ident && (CurrentToken() == Token::kPERIOD)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
@@ skipping 3122 matching lines @@
   }
   if (target->FunctionLevel() != current_block_->scope->function_level()) {
     ErrorMsg(jump_pos, "'%s' target must be in same function context",
              Token::Str(jump_kind));
   }
   return new JumpNode(jump_pos, jump_kind, target);
 }
 
 
 bool Parser::IsDefinedInLexicalScope(const String& ident) {
-  if (ResolveIdentInLocalScope(token_index_, ident, NULL)) {
+  AstNode* var_or_field = NULL;
+  if (ResolveIdentInLocalScope(token_index_, ident, &var_or_field)) {
     return true;
   }
   Object& obj = Object::Handle();
   obj = library_.LookupObject(ident);
   return !obj.IsNull();
 }
 
 
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
@@ skipping 1347 matching lines @@
   return instance.raw();
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
+  ASSERT(node != NULL);
   TRACE_PARSER("ResolveIdentInLocalScope");
+  Isolate* isolate = Isolate::Current();
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (local != NULL) {
-    if (node != NULL) {
-      *node = new LoadLocalNode(ident_pos, *local);
-    }
+    *node = new LoadLocalNode(ident_pos, *local);
     return true;
   }
 
   // Try to find the identifier in the class scope.
-  Class& cls = Class::Handle(current_class().raw());
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
+  Class& cls = Class::Handle(isolate, current_class().raw());
+  Function& func = Function::Handle(isolate, Function::null());
+  Field& field = Field::Handle(isolate, Field::null());
+  String& accessor_name = String::Handle(isolate, String::null());
   while (!cls.IsNull()) {
     // First check if a field exists.
-    field = cls.LookupInstanceField(ident);
+    field = cls.LookupField(ident);
     if (!field.IsNull()) {
-      if (node != NULL) {
+      if (!field.is_static()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
-      }
-      return true;
-    }
-    field = cls.LookupStaticField(ident);
-    if (!field.IsNull()) {
-      if (node != NULL) {
+      } else {
         *node = GenerateStaticFieldLookup(field, ident_pos);
       }
       return true;
     }
 
+    // Check if an instance/static function exists.
+    func = cls.LookupFunction(ident);
+    if (!func.IsNull() &&
+        (func.IsDynamicFunction() || func.IsStaticFunction())) {
+      *node = new PrimaryNode(ident_pos,
+                              Function::ZoneHandle(isolate, func.raw()));
+      return true;
+    }
+
     // Now check if a getter/setter method exists for it in which case
     // it is still a field.
-    const String& getter_name = String::Handle(Field::GetterName(ident));
-    func = cls.LookupDynamicFunction(getter_name);
+    accessor_name = Field::GetterName(ident);
+    func = cls.LookupFunction(accessor_name);
     if (!func.IsNull()) {
-      if (node != NULL) {
+      if (func.IsDynamicFunction()) {
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
-      }
-      return true;
-    }
-    func = cls.LookupStaticFunction(getter_name);
-    if (!func.IsNull()) {
-      if (node != NULL) {
+        return true;
+      } else if (func.IsStaticFunction()) {
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = new StaticGetterNode(ident_pos,
-                                     Class::ZoneHandle(cls.raw()),
+                                     Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
+        return true;
       }
-      return true;
     }
-    const String& setter_name = String::Handle(Field::SetterName(ident));
-    func = cls.LookupDynamicFunction(setter_name);
+    accessor_name = Field::SetterName(ident);
+    func = cls.LookupFunction(accessor_name);
     if (!func.IsNull()) {
-      if (node != NULL) {
+      if (func.IsDynamicFunction()) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
-      }
-      return true;
-    }
-    func = cls.LookupStaticFunction(setter_name);
-    if (!func.IsNull()) {
-      if (node != NULL) {
+        return true;
+      } else if (func.IsStaticFunction()) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         *node = new StaticGetterNode(ident_pos,
-                                     Class::ZoneHandle(cls.raw()),
+                                     Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
+        return true;
       }
-      return true;
     }
 
-    // Check if an instance/static function exists.
-    func = cls.LookupDynamicFunction(ident);
-    if (func.IsNull()) {
-      func = cls.LookupStaticFunction(ident);
-    }
-    if (!func.IsNull()) {
-      if (node != NULL) {
-        *node = new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
-      }
-      return true;
-    }
     cls = cls.SuperClass();
   }
-  if (node != NULL) {
-    *node = NULL;
-  }
+  *node = NULL;
   return false;  // Not an unqualified identifier.
 }
 
 
 // Do a lookup for the identifier in the library scope of the specified
 // library. If resolve_locally is true the lookup does not consider
 // the libraries imported by it for the lookup.
 AstNode* Parser::ResolveIdentInLibraryScope(const Library& lib,
                                             const QualIdent& qual_ident,
                                             bool resolve_locally) {
@@ skipping 1222 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart