Make ClassFinalizer indifferent on whether we are generating a snapshot or not.

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 209 matching lines @@
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script,
-               const Library& library)
+               const Library& library,
+               bool generating_snapshot)
     : script_(script),
       tokens_iterator_(TokenStream::Handle(script.tokens()), 0),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(Function::Handle()),
       innermost_function_(Function::Handle()),
       current_class_(Class::Handle()),
       library_(library),
       try_blocks_list_(NULL),
-      expression_temp_(NULL) {
+      expression_temp_(NULL),
+      class_finalizer_(generating_snapshot) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                const Function& function,
                intptr_t token_position)
     : script_(script),
       tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
       innermost_function_(Function::Handle(function.raw())),
       current_class_(Class::Handle(current_function_.Owner())),
       library_(Library::Handle(current_class_.library())),
       try_blocks_list_(NULL),
-      expression_temp_(NULL)  {
+      expression_temp_(NULL),
+      class_finalizer_(ClassFinalizer::kNotGeneratingSnapshot) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!function.IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
@@ skipping 25 matching lines @@
 void Parser::SetPosition(intptr_t position) {
   if (position < TokenPos() && position != 0) {
     CompilerStats::num_tokens_rewind += (TokenPos() - position);
   }
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 void Parser::ParseCompilationUnit(const Library& library,
-                                  const Script& script) {
+                                  const Script& script,
+                                  bool generating_snapshot) {
   ASSERT(Isolate::Current()->long_jump_base()->IsSafeToJump());
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
-  Parser parser(script, library);
+  Parser parser(script, library, generating_snapshot);
   parser.ParseTopLevel();
 }
 
 
 Token::Kind Parser::CurrentToken() {
   if (token_kind_ == Token::kILLEGAL) {
     token_kind_ = tokens_iterator_.CurrentTokenKind();
     if (token_kind_ == Token::kERROR) {
       ErrorMsg(TokenPos(), CurrentLiteral()->ToCString());
     }
@@ skipping 756 matching lines @@
                                                    signature_function,
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
-        signature_type ^= ClassFinalizer::FinalizeType(
+        signature_type ^= class_finalizer_.FinalizeType(
             signature_class, signature_type, ClassFinalizer::kCanonicalize);
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
     if (!params->has_named_optional_parameters ||
         !allow_explicit_default_value) {
@@ skipping 2411 matching lines @@
         ErrorMsg(interface_pos, "duplicate interface '%s'",
                  interface_name.ToCString());
       }
     }
     interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
   return Array::MakeArray(interfaces);
 }
 
 
+// Add 'interface' to 'interface_list' if it is not already in the list and
+// return true. Also return true if 'interface' is not added, because it is
+// not unique, i.e. it is already in the list.
+// Return false if 'interface' conflicts with an interface already in the list
+// with the same class, but different type arguments.
+// In the case of a conflict, set 'conflicting' to the existing interface.
+static bool AddInterfaceIfUnique(
+    const GrowableObjectArray& interface_list,
+    const AbstractType& interface,
+    AbstractType* conflicting) {
+  String& interface_class_name = String::Handle(interface.ClassName());
+  String& existing_interface_class_name = String::Handle();
+  String& interface_name = String::Handle();
+  String& existing_interface_name = String::Handle();
+  AbstractType& other_interface = AbstractType::Handle();
+  for (intptr_t i = 0; i < interface_list.Length(); i++) {
+    other_interface ^= interface_list.At(i);
+    existing_interface_class_name = other_interface.ClassName();
+    if (interface_class_name.Equals(existing_interface_class_name)) {
+      // Same interface class name, now check names of type arguments.
+      interface_name = interface.Name();
+      existing_interface_name = other_interface.Name();
+      // TODO(regis): Revisit depending on the outcome of issue 4905685.
+      if (!interface_name.Equals(existing_interface_name)) {
+        *conflicting = other_interface.raw();
+        return false;
+      } else {
+        return true;
+      }
+    }
+  }
+  interface_list.Add(interface);
+  return true;
+}
+
+
 void Parser::AddInterfaces(intptr_t interfaces_pos,
                            const Class& cls,
                            const Array& interfaces) {
   const GrowableObjectArray& all_interfaces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   AbstractType& interface = AbstractType::Handle();
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
@@ skipping 10 matching lines @@
                  "interface '%s' may not extend type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
                  String::Handle(interface.UserVisibleName()).ToCString());
       } else {
         ErrorMsg(interfaces_pos,
                  "class '%s' may not implement type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
                  String::Handle(interface.UserVisibleName()).ToCString());
       }
     }
-    if (!ClassFinalizer::AddInterfaceIfUnique(all_interfaces,
-                                              interface,
-                                              &conflicting)) {
+    if (!AddInterfaceIfUnique(all_interfaces, interface, &conflicting)) {
       ASSERT(!conflicting.IsNull());
       ErrorMsg(interfaces_pos,

[hausner, 2012/08/22 00:15:39]

I think you could emit the error message in AddInterfaceIfUnique directly, now
that you hoisted that function into the parser.

[regis, 2012/08/22 02:24:26]

Done, but I needed to make AddInterfaceIfUnique an instance function.

                "interface '%s' conflicts with interface '%s'",
                String::Handle(interface.UserVisibleName()).ToCString(),
                String::Handle(conflicting.UserVisibleName()).ToCString());
     }
   }
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
@@ skipping 963 matching lines @@
     CaptureInstantiator();
   }
 
   // Since the signature type is cached by the signature class, it may have
   // been finalized already.
   Type& signature_type = Type::Handle(signature_class.SignatureType());
   AbstractTypeArguments& signature_type_arguments =
       AbstractTypeArguments::Handle(signature_type.arguments());
 
   if (!signature_type.IsFinalized()) {
-    signature_type ^= ClassFinalizer::FinalizeType(
+    signature_type ^= class_finalizer_.FinalizeType(
         signature_class, signature_type, ClassFinalizer::kCanonicalize);
 
-    // The call to ClassFinalizer::FinalizeType may have
-    // extended the vector of type arguments.
+    // The call to FinalizeType may have extended the vector of type arguments.
     signature_type_arguments = signature_type.arguments();
     ASSERT(signature_type.IsMalformed() ||
            signature_type_arguments.IsNull() ||
            (signature_type_arguments.Length() ==
             signature_class.NumTypeArguments()));
 
     // The signature_class should not have changed.
     ASSERT(signature_type.IsMalformed() ||
            (signature_type.type_class() == signature_class.raw()));
   }
@@ skipping 2718 matching lines @@
                                    unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       // The type is malformed.
-      ClassFinalizer::FinalizeMalformedType(
+      class_finalizer_.FinalizeMalformedType(
           Error::Handle(),  // No previous error.
           current_class(), parameterized_type, finalization,
           "type '%s' is not loaded",
           String::Handle(parameterized_type.UserVisibleName()).ToCString());
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
@@ skipping 57 matching lines @@
 
 const Type* Parser::ReceiverType(intptr_t type_pos) const {
   ASSERT(!current_class().IsNull());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (current_class().NumTypeParameters() > 0) {
     type_arguments = current_class().type_parameters();
   }
   Type& type = Type::ZoneHandle(
        Type::New(current_class(), type_arguments, type_pos));
   if (!is_top_level_) {
-    type ^= ClassFinalizer::FinalizeType(
+    type ^= class_finalizer_.FinalizeType(
         current_class(), type, ClassFinalizer::kCanonicalizeWellFormed);
   }
   return &type;
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   Function& outer_function = Function::Handle(current_function().raw());
   while (outer_function.IsLocalFunction()) {
@@ skipping 586 matching lines @@
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
     parameterized_type.set_arguments(AbstractTypeArguments::Handle());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
     ResolveTypeFromClass(scope_class, finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
-      type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
+      type ^= class_finalizer_.FinalizeType(
+          current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
@@ skipping 566 matching lines @@
           type_argument = type_arguments.TypeAt(i);
         } else {
           type_argument = Type::DynamicType();
         }
         temp_type_arguments.SetTypeAt(i, type_argument);
       }
     }
     Type& temp_type = Type::Handle(Type::New(
          constructor_class, temp_type_arguments, type.token_pos(), Heap::kNew));
     // No need to canonicalize temporary type.
-    temp_type ^= ClassFinalizer::FinalizeType(
+    temp_type ^= class_finalizer_.FinalizeType(
         current_class(), temp_type, ClassFinalizer::kFinalize);
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the temporary type.
     type_arguments = temp_type.arguments();
     // The type parameter bounds of the factory class may be more specific than
     // the type parameter bounds of the interface class. Therefore, although
     // type was not malformed, temp_type may be malformed.
     if (!type.IsMalformed() && temp_type.IsMalformed()) {
       const Error& error = Error::Handle(temp_type.malformed_error());
       type.set_malformed_error(error);
@@ skipping 621 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart