Enumerate URIs of all types in type errors in order to help the user diagnose

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 6136 matching lines @@
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
     *bound_error = LanguageError::NewFormatted(
         *bound_error,  // A bound error if non null.
         Script::Handle(other.script()),
         other.token_pos(),
         Report::AtLocation,
         Report::kError,
         Heap::kNew,
         "signature type '%s' of function '%s' is not a subtype of signature "
-        "type '%s' of function '%s'",
+        "type '%s' of function '%s' where\n%s%s",
         String::Handle(UserVisibleSignature()).ToCString(),
         String::Handle(UserVisibleName()).ToCString(),
         String::Handle(other.UserVisibleSignature()).ToCString(),
-        String::Handle(other.UserVisibleName()).ToCString());
+        String::Handle(other.UserVisibleName()).ToCString(),
+        String::Handle(FunctionType::Handle(
+            SignatureType()).EnumerateURIs()).ToCString(),
+        String::Handle(FunctionType::Handle(
+            other.SignatureType()).EnumerateURIs()).ToCString());
     return false;
   }
   // We should also check that if the other function explicitly specifies a
   // default value for a formal parameter, this function does not specify a
   // different default value for the same parameter. However, this check is not
   // possible in the current implementation, because the default parameter
   // values are not stored in the Function object, but discarded after a
   // function is compiled.
   return true;
 }
@@ skipping 1787 matching lines @@
 
     // Handle the current token.
     if (curr == Token::kSTRING) {
       bool escape_characters = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
         if (NeedsEscapeSequence(literal.CharAt(i))) {
           escape_characters = true;
         }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
-        literals.Add(Symbols::DoubleQuotes());
+        literals.Add(Symbols::DoubleQuote());
       }
       if (escape_characters) {
         literal = String::EscapeSpecialCharacters(literal);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
-        literals.Add(Symbols::DoubleQuotes());
+        literals.Add(Symbols::DoubleQuote());
       }
     } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(Symbols::Dollar());
       if (literal.CharAt(0) == Library::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else if (curr == Token::kIDENT) {
       if (literal.CharAt(0) == Library::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
@@ skipping 7332 matching lines @@
 //   MyClass<dynamic, T> -> MyClass<dynamic, T> where
 //                            MyClass is from my_uri
 //                            T of OtherClass is from other_uri
 //   (MyClass) => int    -> (MyClass) => int where
 //                            MyClass is from my_uri
 //                            int is from dart:core
 RawString* AbstractType::UserVisibleNameWithURI() const {
   Zone* zone = Thread::Current()->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 3);
   pieces.Add(String::Handle(zone, BuildName(kUserVisibleName)));
-  pieces.Add(Symbols::SpaceWhereNewLine());
-  pieces.Add(String::Handle(zone, EnumerateURIs()));
+  if (!IsDynamicType() && !IsVoidType()) {
+    pieces.Add(Symbols::SpaceWhereNewLine());
+    pieces.Add(String::Handle(zone, EnumerateURIs()));
+  }
   return Symbols::FromConcatAll(pieces);
 }
 
 
 RawString* AbstractType::ClassName() const {
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
@@ skipping 700 matching lines @@
     return this->raw();
   }
   set_arguments(type_args);
   ASSERT(type_args.IsNull() || type_args.IsOld());
 
   return cls.LookupOrAddCanonicalType(*this, index);
 }
 
 
 RawString* Type::EnumerateURIs() const {
-  if (IsDynamicType()) {
+  if (IsDynamicType() || IsVoidType()) {
     return Symbols::Empty().raw();
   }
   Zone* zone = Thread::Current()->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 6);
   const Class& cls = Class::Handle(zone, type_class());
   pieces.Add(Symbols::TwoSpaces());
   pieces.Add(String::Handle(zone, cls.UserVisibleName()));
   pieces.Add(Symbols::SpaceIsFromSpace());
   const Library& library = Library::Handle(zone, cls.library());
   pieces.Add(String::Handle(zone, library.url()));
@@ skipping 469 matching lines @@
   const Function& sig_fun = Function::Handle(zone, signature());
   AbstractType& type = AbstractType::Handle(zone);
   const intptr_t num_params = sig_fun.NumParameters();
   GrowableHandlePtrArray<const String> pieces(zone, num_params + 1);
   for (intptr_t i = 0; i < num_params; i++) {
     type = sig_fun.ParameterTypeAt(i);
     pieces.Add(String::Handle(zone, type.EnumerateURIs()));
   }
   // Handle result type last, since it appears last in the user visible name.
   type = sig_fun.result_type();
-  if (!type.IsDynamicType() && !type.IsVoidType()) {
-    pieces.Add(String::Handle(zone, type.EnumerateURIs()));
-  }
+  pieces.Add(String::Handle(zone, type.EnumerateURIs()));
   return Symbols::FromConcatAll(pieces);
 }
 
 
 intptr_t FunctionType::Hash() const {
   ASSERT(IsFinalized());
   uint32_t result = 1;
   if (IsMalformed()) return result;
   result = CombineHashes(result, Class::Handle(scope_class()).id());
   result = CombineHashes(result, TypeArguments::Handle(arguments()).Hash());
@@ skipping 188 matching lines @@
   // TODO(regis): Try to reduce the number of nodes required to represent the
   // referenced recursive type.
   AbstractType& ref_type = AbstractType::Handle(type());
   ref_type = ref_type.Canonicalize(trail);
   set_type(ref_type);
   return raw();
 }
 
 
 RawString* TypeRef::EnumerateURIs() const {
-  return Symbols::Empty().raw();  // Break cycle.
+  const AbstractType& ref_type = AbstractType::Handle(type());
+  ASSERT(!ref_type.IsDynamicType() && !ref_type.IsVoidType());
+  Zone* zone = Thread::Current()->zone();
+  GrowableHandlePtrArray<const String> pieces(zone, 6);
+  const Class& cls = Class::Handle(zone, ref_type.type_class());
+  pieces.Add(Symbols::TwoSpaces());
+  pieces.Add(String::Handle(zone, cls.UserVisibleName()));
+  // Break cycle by not printing type arguments, but '<optimized out>' instead.
+  pieces.Add(Symbols::OptimizedOut());
+  pieces.Add(Symbols::SpaceIsFromSpace());
+  const Library& library = Library::Handle(zone, cls.library());
+  pieces.Add(String::Handle(zone, library.url()));
+  pieces.Add(Symbols::NewLine());
+  return Symbols::FromConcatAll(pieces);
 }
 
 
 intptr_t TypeRef::Hash() const {
   // Do not calculate the hash of the referenced type to avoid divergence.
   const uint32_t result =
       Class::Handle(AbstractType::Handle(type()).type_class()).id();
   return FinalizeHash(result);
 }
 
@@ skipping 148 matching lines @@
       // Since the bound may have been canonicalized, its token index is
       // meaningless, therefore use the token index of this type parameter.
       *bound_error = LanguageError::NewFormatted(
           *bound_error,
           script,
           token_pos(),
           Report::AtLocation,
           Report::kMalboundedType,
           Heap::kNew,
           "type parameter '%s' of class '%s' must extend bound '%s', "
-          "but type argument '%s' is not a subtype of '%s'\n",
+          "but type argument '%s' is not a subtype of '%s' where\n%s%s",
           type_param_name.ToCString(),
           class_name.ToCString(),
           declared_bound_name.ToCString(),
           bounded_type_name.ToCString(),
-          upper_bound_name.ToCString());
+          upper_bound_name.ToCString(),
+          String::Handle(bounded_type.EnumerateURIs()).ToCString(),
+          String::Handle(upper_bound.EnumerateURIs()).ToCString());
     }
   }
   return false;
 }
 
 
 RawAbstractType* TypeParameter::CloneUnfinalized() const {
   if (IsFinalized()) {
     return raw();
   }
@@ skipping 4937 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart