Fix expression evaluation in library context

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 290 matching lines @@
         GrowableObjectArray::Handle(
             isolate()->object_store()->pending_functions());
     ASSERT(pending_functions.Length() > 0);
     ASSERT(pending_functions.At(pending_functions.Length()-1) ==
         current_function().raw());
     pending_functions.RemoveLast();
   }
 }
 
 
-void Parser::SetScript(const Script & script, intptr_t token_pos) {
+void Parser::SetScript(const Script& script, intptr_t token_pos) {
   script_ = script.raw();
   tokens_iterator_.SetStream(TokenStream::Handle(script.tokens()), token_pos);
   token_kind_ = Token::kILLEGAL;
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
@@ skipping 2794 matching lines @@
   String& redirection_identifier = String::Handle();
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kResolveTypeParameters));
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(),  // No previous error.
-          current_class(),
+          script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
           String::Handle(type.UserVisibleName()).ToCString());
     } else {
       // TODO(regis): What if the redirection type is malbounded?
       redirection_type ^= type.raw();
     }
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
@@ skipping 5392 matching lines @@
             scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
           // referenced by a static member.
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
             if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
                 FLAG_error_on_bad_type) {
               *type = ClassFinalizer::NewFinalizedMalformedType(
                   Error::Handle(),  // No previous error.
-                  scope_class,
+                  script_,
                   type->token_pos(),
                   "type parameter '%s' cannot be referenced "
                   "from static member",
                   String::Handle(type_parameter.name()).ToCString());
             } else {
               // Map the malformed type to dynamic and ignore type arguments.
               *type = Type::DynamicType();
             }
             return;
           }
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
             if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
                 FLAG_error_on_bad_type) {
               *type = ClassFinalizer::NewFinalizedMalformedType(
                   Error::Handle(),  // No previous error.
-                  scope_class,
+                  script_,
                   type_parameter.token_pos(),
                   "type parameter '%s' cannot be parameterized",
                   String::Handle(type_parameter.name()).ToCString());
             } else {
               // Map the malformed type to dynamic and ignore type arguments.
               *type = Type::DynamicType();
             }
             return;
           }
           *type = type_parameter.raw();
@@ skipping 17 matching lines @@
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
           FLAG_error_on_bad_type) {
         ClassFinalizer::FinalizeMalformedType(
             Error::Handle(),  // No previous error.
-            scope_class,
+            script_,
             parameterized_type,
             "type '%s' is not loaded",
             String::Handle(parameterized_type.UserVisibleName()).ToCString());
       } else {
         // Map the malformed type to dynamic and ignore type arguments.
         *type = Type::DynamicType();
       }
       return;
     }
   }
@@ skipping 574 matching lines @@
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       if (finalization == ClassFinalizer::kCanonicalizeWellFormed) {
         return ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(),  // No previous error.
-            current_class(),
+            script_,
             type_name.ident_pos,
             "using '%s' in this context is invalid",
             type_name.ident->ToCString());
       }
       return Type::DynamicType();
     }
   }
   Object& type_class = Object::Handle(isolate());
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
@@ skipping 542 matching lines @@
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeWellFormed));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
   if (!type.IsMalformed()) {
     if (type.IsTypeParameter() || type.IsDynamicType()) {
       // Replace the type with a malformed type.
       type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(),  // No previous error.
-          current_class(),
+          script_,
           type_pos,
           "%s'%s' cannot be instantiated",
           type.IsTypeParameter() ? "type parameter " : "",
           type.IsTypeParameter() ?
               String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
     } else if (FLAG_enable_type_checks || FLAG_error_on_bad_type) {
       Error& bound_error = Error::Handle();
       if (type.IsMalboundedWithError(&bound_error)) {
         // Replace the type with a malformed type.
         type = ClassFinalizer::NewFinalizedMalformedType(
             bound_error,
-            current_class(),
+            script_,
             type_pos,
             "malbounded type '%s' cannot be instantiated",
             String::Handle(type.UserVisibleName()).ToCString());
       }
     }
   }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType() above will not consume it as
   // part of a misinterpreted qualified identifier, because only a valid library
@@ skipping 44 matching lines @@
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : type_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(),  // No previous error.
-            current_class(),
+            script_,
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
             String::Handle(type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
@@ skipping 105 matching lines @@
                                    Instance::ZoneHandle(const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle();
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
                                          TypeArguments::Handle(),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
               malformed_error,
-              current_class(),
+              script_,
               new_pos,
               "const factory result is not an instance of '%s'",
               String::Handle(type_bound.UserVisibleName()).ToCString());
           new_object = ThrowTypeError(new_pos, type_bound);
         }
         type_bound = AbstractType::null();
       }
     }
   } else {
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
@@ skipping 642 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart