Fix expression evaluation in library context

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 319 matching lines @@
   factory.SetRedirectionType(type);
   if (type.IsMalformed()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
-        cls,
+        Script::Handle(cls.script()),
         factory.token_pos(),
         "factory may not redirect to 'dynamic'");
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   const Class& target_class = Class::Handle(type.type_class());
   String& target_class_name = String::Handle(target_class.Name());
   String& target_name = String::Handle(
       String::Concat(target_class_name, Symbols::Dot()));
   const String& identifier = String::Handle(factory.RedirectionIdentifier());
   if (!identifier.IsNull()) {
     target_name = String::Concat(target_name, identifier);
   }
 
   // Verify that the target constructor of the redirection exists.
   target = target_class.LookupConstructor(target_name);
   if (target.IsNull()) {
     target = target_class.LookupFactory(target_name);
   }
   if (target.IsNull()) {
     const String& user_visible_target_name =
         identifier.IsNull() ? target_class_name : target_name;
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
-        cls,
+        Script::Handle(target_class.script()),
         factory.token_pos(),
         "class '%s' has no constructor or factory named '%s'",
         target_class_name.ToCString(),
         user_visible_target_name.ToCString());
     factory.SetRedirectionType(type);
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
 
   if (FLAG_error_on_bad_override) {
     // Verify that the target is compatible with the redirecting factory.
     Error& error = Error::Handle();
     if (!target.HasCompatibleParametersWith(factory, &error)) {
+      const Script& script = Script::Handle(target_class.script());
       type = NewFinalizedMalformedType(
-          error, target_class, target.token_pos(),
+          error, script, target.token_pos(),
           "constructor '%s' has incompatible parameters with "
           "redirecting factory '%s'",
           String::Handle(target.name()).ToCString(),
           String::Handle(factory.name()).ToCString());
       factory.SetRedirectionType(type);
       ASSERT(factory.RedirectionTarget() == Function::null());
       return;
     }
   }
 
@@ skipping 28 matching lines @@
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
           type.arguments());
       Error& malformed_error = Error::Handle();
       target_type ^= target_type.InstantiateFrom(type_args, &malformed_error);
       if (malformed_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
-        FinalizeMalformedType(malformed_error, cls, target_type,
+        const Script& script = Script::Handle(target_class.script());
+        FinalizeMalformedType(malformed_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
 
@@ skipping 22 matching lines @@
         Class::Handle(ResolveClass(cls, unresolved_class));
 
     // Replace unresolved class with resolved type class.
     const Type& parameterized_type = Type::Cast(type);
     if (type_class.IsNull()) {
       if ((finalization == kCanonicalizeWellFormed) ||
           FLAG_error_on_bad_type) {
         // The type class could not be resolved. The type is malformed.
         FinalizeMalformedType(
             Error::Handle(),  // No previous error.
-            cls,
+            Script::Handle(cls.script()),
             parameterized_type,
             "cannot resolve class '%s' from '%s'",
             String::Handle(unresolved_class.Name()).ToCString(),
             String::Handle(cls.Name()).ToCString());
       } else {
         // Map the malformed type to dynamic and ignore type arguments.
         parameterized_type.set_type_class(Class::Handle(
             Object::dynamic_class()));
         parameterized_type.set_arguments(
             Object::null_abstract_type_arguments());
@@ skipping 414 matching lines @@
   }
 
   // If a bound error occurred, return a BoundedType with a malformed bound.
   // The malformed bound will be ignored in production mode.
   if (!bound_error.IsNull()) {
     // No compile-time error during finalization.
     const String& parameterized_type_name = String::Handle(
         parameterized_type.UserVisibleName());
     const Type& malformed_bound = Type::Handle(
         NewFinalizedMalformedType(bound_error,
-                                  cls,
+                                  Script::Handle(cls.script()),
                                   parameterized_type.token_pos(),
                                   "type '%s' has an out of bound type argument",
                                   parameterized_type_name.ToCString()));
     return BoundedType::New(parameterized_type,
                             malformed_bound,
                             TypeParameter::Handle());
   }
 
   if (finalization >= kCanonicalize) {
     return parameterized_type.Canonicalize();
@@ skipping 1519 matching lines @@
   Field& field = Field::Handle();
   len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     OS::Print("  %s\n", field.ToCString());
   }
 }
 
 // Either report an error or mark the type as malformed.
 void ClassFinalizer::ReportMalformedType(const Error& prev_error,
-                                         const Class& cls,
+                                         const Script& script,
                                          const Type& type,
                                          const char* format,
                                          va_list args) {
   LanguageError& error = LanguageError::Handle();
-  const Script& script = Script::Handle(cls.script());
   if (prev_error.IsNull()) {
     error ^= Parser::FormatError(
         script, type.token_pos(), "Error", format, args);
   } else {
     error ^= Parser::FormatErrorWithAppend(
         prev_error, script, type.token_pos(), "Error", format, args);
   }
   if (FLAG_error_on_bad_type) {
     ReportError(error);
   }
   type.set_malformed_error(error);
   // Make the type raw, since it may not be possible to
   // properly finalize its type arguments.
   type.set_type_class(Class::Handle(Object::dynamic_class()));
   type.set_arguments(Object::null_abstract_type_arguments());
   if (!type.IsFinalized()) {
     type.SetIsFinalized();
     // Do not canonicalize malformed types, since they may not be resolved.
   } else {
     // The only case where the malformed type was already finalized is when its
     // type arguments are not within bounds. In that case, we have a prev_error.
     ASSERT(!prev_error.IsNull());
   }
 }
 
 
 RawType* ClassFinalizer::NewFinalizedMalformedType(const Error& prev_error,
-                                                   const Class& cls,
+                                                   const Script& script,
                                                    intptr_t type_pos,
                                                    const char* format, ...) {
   va_list args;
   va_start(args, format);
   const UnresolvedClass& unresolved_class = UnresolvedClass::Handle(
       UnresolvedClass::New(LibraryPrefix::Handle(),
                            Symbols::Empty(),
                            type_pos));
   const Type& type = Type::Handle(
       Type::New(unresolved_class, TypeArguments::Handle(), type_pos));
-  ReportMalformedType(prev_error, cls, type, format, args);
+  ReportMalformedType(prev_error, script, type, format, args);
   va_end(args);
   ASSERT(type.IsMalformed());
   ASSERT(type.IsFinalized());
   return type.raw();
 }
 
 
 void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
-                                           const Class& cls,
+                                           const Script& script,
                                            const Type& type,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
-  ReportMalformedType(prev_error, cls, type, format, args);
+  ReportMalformedType(prev_error, script, type, format, args);
   va_end(args);
 }
 
 
 void ClassFinalizer::ReportError(const Error& error) {
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
@@ skipping 78 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart