Fixing bugs: 1612, 1843, 1847

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 2713 matching lines @@
     signature_class = Class::NewSignatureClass(signature,
                                                signature_function,
                                                script_);
     // Record the function signature class in the current library.
     library_.AddClass(signature_class);
   } else {
     // 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());
-  // Lookup the class by its alias name and report an error if it exists.
-  Class& function_type_alias =
-      Class::ZoneHandle(library_.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_);
-    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());
+
+  // Lookup alias name and report an error if it is already defined in
+  // the library scope.
+  const Object& obj = Object::Handle(library_.LookupObject(*alias_name));
+  if (!obj.IsNull()) {
+    ErrorMsg(alias_name_pos,
+             "'%s' is already defined", alias_name->ToCString());
   }
+
+  // Create the function type alias, but share the signature function of the
+  // canonical signature class.
+  Class& function_type_alias = Class::ZoneHandle(
+      Class::NewSignatureClass(*alias_name,
+                               signature_function,
+                               script_));
+  library_.AddClass(function_type_alias);
   ExpectSemicolon();
   classes->Add(&function_type_alias);
 }
 
 
 void Parser::ParseInterfaceDefinition(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
   const intptr_t interface_pos = token_index_;
   ExpectToken(Token::kINTERFACE);
   const intptr_t interfacename_pos = token_index_;
@@ skipping 4430 matching lines @@
 
 AstNode* Parser::ParseNewOperator() {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = token_index_;
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
+  intptr_t type_pos = token_index_;
 
   const AbstractType& type = AbstractType::Handle(ParseType(kMustResolve));
   if (type.IsTypeParameter()) {
-    ErrorMsg(type.token_index(),
+    ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
              String::Handle(type.Name()).ToCString());
   }
   Class& type_class = Class::Handle(type.type_class());
   String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
   // The constructor class and its name are those of the parsed type, unless the
   // parsed type is an interface and a default factory class is specified, in
   // which case constructor_class and constructor_class_name are modified below.
   Class& constructor_class = Class::ZoneHandle(type_class.raw());
   String& constructor_class_name = String::Handle(type_class_name.raw());
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType(kMustResolve) above will not
   // consume it as part of a misinterpreted qualified identifier, because only a
   // valid library prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
   }
 
   // Parse constructor parameters.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
+  intptr_t call_pos = token_index_;
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
   if (type_class.is_interface()) {
     // We need to make sure that an appropriate constructor is
     // declared in the interface.
     const String& constructor_name =
         BuildConstructorName(type_class_name, named_constructor);
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
     if (constructor.IsNull()) {
-      ErrorMsg(type.token_index(),
+      ErrorMsg(type_pos,
                "interface '%s' has no constructor named '%s'",
                type_class_name.ToCString(),
                external_constructor_name.ToCString());
     }
     if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
-      ErrorMsg(type.token_index(),
+      ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
                "for interface '%s'",
                external_constructor_name.ToCString(),
                type_class_name.ToCString());
     }
     if (!type_class.HasFactoryClass()) {
-      ErrorMsg("cannot allocate interface '%s' without factory class",
+      ErrorMsg(type_pos,
+               "cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
     if (!type_class.HasResolvedFactoryClass()) {
       // This error can occur only with bootstrap classes.
       const UnresolvedClass& unresolved =
           UnresolvedClass::Handle(type_class.UnresolvedFactoryClass());
       const String& missing_class_name = String::Handle(unresolved.ident());
       ErrorMsg("unresolved factory class '%s'", missing_class_name.ToCString());
     }
     // Only change the class of the constructor to the factory class if the
@@ skipping 18 matching lines @@
   Function& constructor = Function::ZoneHandle(
       constructor_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = constructor_class.LookupFactory(constructor_name);
     // A factory does not have the implicit 'phase' parameter.
     arguments_length -= 1;
   }
   if (constructor.IsNull()) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(type.token_index(),
+    ErrorMsg(type_pos,
              "class '%s' has no constructor or factory named '%s'",
              String::Handle(constructor_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
   if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(type.token_index(),
+    ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s' for class '%s'",
              external_constructor_name.ToCString(),
              String::Handle(constructor_class.Name()).ToCString());
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   // The type argument vector of the parsed type was finalized in ParseType.
   // If the constructor class was changed from the interface class to the
   // factory class, we need to finalize the type argument vector again, because
@@ skipping 590 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart