Revert r1380 that is breaking frog.

runtime/vm/parser.cc

 // Copyright (c) 2011, 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 156 matching lines @@
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(Function::Handle()),
       current_class_(Class::Handle()),
       library_(library),
       try_blocks_list_(NULL) {
-  ASSERT(!tokens_.IsNull());
-  ASSERT(!library.IsNull());
   SetPosition(0);
 }
 
 
 Parser::Parser(const Script& script,
                const Function& function,
                intptr_t token_index)
     : script_(script),
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
       current_class_(Class::Handle(current_function_.owner())),
       library_(Library::Handle(current_class_.library())),
       try_blocks_list_(NULL) {
-  ASSERT(!tokens_.IsNull());
-  ASSERT(!function.IsNull());
   SetPosition(token_index);
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
 }
 
@@ skipping 2400 matching lines @@
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("function alias name expected");
   }
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name = CurrentLiteral();
   ConsumeToken();
 
   // Allocate an interface to hold the type parameters and their 'extends'
   // constraints. Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
-      Class::New(String::Handle(String::NewSymbol(":alias_owner")),
-                 Script::Handle()));
+      Class::New(String::Handle(String::NewSymbol("")), Script::Handle()));
   alias_owner.set_is_interface();
   set_current_class(alias_owner);
   ParseTypeParameters(alias_owner);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
 
   // At this point, the type parameters have been parsed, so we can resolve the
   // result type.
   if (!result_type.IsNull() && !result_type.IsResolved()) {
@@ skipping 574 matching lines @@
 
 void Parser::ParseTopLevel() {
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   GrowableArray<const Class*> classes;
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::ZoneHandle(
-      Class::New(String::ZoneHandle(String::NewSymbol("::")), script_));
+      Class::New(String::ZoneHandle(String::NewSymbol("")), script_));
   toplevel_class.set_library(library_);
 
-  // We notify the class finalizer to expect classes to finalize.
-  // This allows signature classes generated at runtime to be properly
-  // finalized, without finalizing them prematurely at compile time.
-  ClassFinalizer::ExpectClassesToFinalize();
-
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(&classes);
     } else if (CurrentToken() == Token::kTYPEDEF) {
       ParseFunctionTypeAlias(&classes);
@@ skipping 15 matching lines @@
     }
   }
   if ((top_level.fields.length() > 0) || (top_level.functions.length() > 0)) {
     toplevel_class.SetFields(
         Array::Handle(NewArray<Field>(top_level.fields)));
     toplevel_class.SetFunctions(
         Array::Handle(NewArray<Function>(top_level.functions)));
     library_.AddAnonymousClass(toplevel_class);
     classes.Add(&toplevel_class);
   }
-  ClassFinalizer::AddClassesToFinalize(classes);
+  ClassFinalizer::AddPendingClasses(classes);
 }
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
   Block* block = new Block(current_block_,
                            outer_scope,
                            new SequenceNode(token_index_, outer_scope));
   current_block_ = block;
 }
 
@@ skipping 413 matching lines @@
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
       String& errmsg = String::Handle();
       signature_type =
           ClassFinalizer::FinalizeAndCanonicalizeType(signature_type, &errmsg);
       if (!errmsg.IsNull()) {
         ErrorMsg(errmsg.ToCString());
       }
-      // The call to ClassFinalizer::FinalizeAndCanonicalizeType may have
-      // extended the vector of type arguments.
+      // The call to ClassFinalizer::FinalizeTypeWhileParsing may have extended
+      // the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
     }
 
     // Now patch the function type of the variable.
     function_type.set_type_class(signature_class);
     function_type.set_arguments(signature_type_arguments);
@@ skipping 3572 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart