Fix wrong detection of duplicate definition of function types (issue 187).

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 831 matching lines @@
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         parameter.name_pos));
       signature_function.set_owner(current_class());
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(signature_function.Signature());
-      // Lookup the class named signature and only create a new class if it does
-      // not exist yet.
-      Class& signature_class = Class::ZoneHandle(LookupClass(signature));
+      // Lookup the signature class, i.e. the class whose name is the signature.
+      // We only lookup in the current library, but not in its imports, and only
+      // create a new canonical signature class if it does not exist yet.
+      Class& signature_class = Class::ZoneHandle(
+          library_.LookupLocalClass(signature));
       if (signature_class.IsNull()) {
         signature_class = Class::NewSignatureClass(signature,
                                                    signature_function,
-                                                   script_,
-                                                   parameter.name_pos);
-        // Record the function signature class in the library.
+                                                   script_);
+        // Record the function signature class in the current library.
         library_.AddClass(signature_class);
+      } else {
+        signature_function.set_signature_class(signature_class);
       }
-      ASSERT(!Function::Handle(signature_class.signature_function()).IsNull());
-      ASSERT(Class::Handle(signature_function.signature_class()).IsNull());
-      signature_function.set_signature_class(signature_class);
-
+      ASSERT(signature_function.signature_class() == signature_class.raw());
       // The type of the parameter is now the signature type.
       parameter.type = &Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !parameter.type->IsFinalized()) {
         const String& errmsg = String::Handle(
             ClassFinalizer::FinalizeTypeWhileParsing(*parameter.type));
         if (!errmsg.IsNull()) {
           ErrorMsg(errmsg.ToCString());
         }
       }
     }
@@ skipping 1535 matching lines @@
                     /* is_const = */ false,
                     alias_name_pos));
   signature_function.set_owner(alias_owner);
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
   const String& signature = String::Handle(signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
-  // Lookup the class by its signature and only create a new canonical signature
-  // class if it does not exist yet.
-  Class& signature_class = Class::ZoneHandle(LookupClass(signature));
+  // Lookup the signature class, i.e. the class whose name is the signature.
+  // We only lookup in the current library, but not in its imports, and only
+  // create a new canonical signature class if it does not exist yet.
+  Class& signature_class = Class::ZoneHandle(
+      library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     signature_class = Class::NewSignatureClass(signature,
                                                signature_function,
-                                               script_,
-                                               alias_name_pos);
-    // Record the function signature class in the library.
+                                               script_);
+    // Record the function signature class in the current library.
     library_.AddClass(signature_class);
-    ASSERT(Class::Handle(signature_function.signature_class()).IsNull());
-    signature_function.set_signature_class(signature_class);
   } else {
-    // Forget the just created function type desc and use the existing one.
+    // Forget the just created signature function and use the existing one.
     signature_function = signature_class.signature_function();
-    ASSERT(signature_function.signature_class() == signature_class.raw());
   }
+  ASSERT(signature_function.signature_class() == signature_class.raw());
   // Lookup the class by its alias name and report an error if it exists.
   Class& function_type_alias = Class::ZoneHandle(LookupClass(*alias_name));
   if (function_type_alias.IsNull()) {
     // Create the function type alias, but share the signature function of the
     // canonical signature class.
     function_type_alias = Class::NewSignatureClass(*alias_name,
                                                    signature_function,
-                                                   script_,
-                                                   alias_name_pos);
+                                                   script_);
     library_.AddClass(function_type_alias);
   } else {
     const char* format = function_type_alias.is_interface() ?
         "'%s' is already defined" : "'%s' is already defined as class";
     ErrorMsg(alias_name_pos, format, alias_name->ToCString());
   }
   ExpectSemicolon();
   classes->Add(&function_type_alias);
 }
 
@@ skipping 950 matching lines @@
       ErrorMsg(ident_pos, "identifier '%s' already defined",
                function_variable->name().ToCString());
     }
   }
 
   // Parse the local function.
   Array& default_parameter_values = Array::Handle();
   SequenceNode* statements = Parser::ParseFunc(function,
                                                default_parameter_values);
 
-  // Now that the local function has formal parameters, lookup or create a new
-  // signature class for it.
+  // Now that the local function has formal parameters, lookup the signature
+  // class in the current library (but not in its imports) and only create a new
+  // canonical signature class if it does not exist yet.
   const String& signature = String::Handle(function.Signature());
-  Class& signature_class = Class::Handle(LookupClass(signature));
+  Class& signature_class = Class::ZoneHandle(
+      library_.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     signature_class = Class::NewSignatureClass(signature,
                                                function,
-                                               script_,
-                                               ident_pos);
-    // Record the function signature class in the library.
+                                               script_);
+    // Record the function signature class in the current library.
     library_.AddClass(signature_class);
+  } else {
+    function.set_signature_class(signature_class);
   }
-  ASSERT(!Function::Handle(signature_class.signature_function()).IsNull());
-  ASSERT(Class::Handle(function.signature_class()).IsNull());
-  function.set_signature_class(signature_class);
-
+  ASSERT(function.signature_class() == signature_class.raw());
   // Local functions are not registered in the enclosing class, which is already
   // finalized.
   ASSERT(current_class().is_finalized());
 
   // Make sure that the instantiator is captured.
   if ((signature_class.NumTypeParameters() > 0) &&
       (current_block_->scope->function_level() > 0)) {
     CaptureReceiver();
   }
 
@@ skipping 3561 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart