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 208 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TryBlocks);
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
-Parser::Parser(const Script& script,
-               const Library& library)
+Parser::Parser(const Script& script, const Library& library)
     : 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()),
@@ skipping 3272 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.
+// An error is reported if the interface conflicts with an interface already in
+// the list with the same class, but different type arguments.
+// Non-conflicting duplicates are ignored without error.
+void Parser::AddInterfaceIfUnique(intptr_t interfaces_pos,
+                                  const GrowableObjectArray& interface_list,
+                                  const AbstractType& interface) {
+  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)) {
+        ErrorMsg(interfaces_pos,
+                 "interface '%s' conflicts with interface '%s'",
+                 String::Handle(interface.UserVisibleName()).ToCString(),
+                 String::Handle(other_interface.UserVisibleName()).ToCString());
+      }
+    }
+  }
+  interface_list.Add(interface);
+}
+
+
 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);
     all_interfaces.Add(interface);
   }
   // Now add the new interfaces.
-  AbstractType& conflicting = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
     if (interface.IsTypeParameter()) {
       if (cls.is_interface()) {
         ErrorMsg(interfaces_pos,
                  "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)) {
-      ASSERT(!conflicting.IsNull());
-      ErrorMsg(interfaces_pos,
-               "interface '%s' conflicts with interface '%s'",
-               String::Handle(interface.UserVisibleName()).ToCString(),
-               String::Handle(conflicting.UserVisibleName()).ToCString());
-    }
+    AddInterfaceIfUnique(interfaces_pos, all_interfaces, interface);
   }
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_const = (CurrentToken() == Token::kCONST);
@@ skipping 5616 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart