Support initialized mixin fields across scripts

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/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 243 matching lines @@
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script, const Library& library)
-    : script_(script),
+    : script_(Script::Handle(script.raw())),
       tokens_iterator_(TokenStream::Handle(script.tokens()), 0),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(NULL),
       innermost_function_(Function::Handle()),
       current_class_(Class::Handle()),
-      library_(library),
+      library_(Library::Handle(library.raw())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                intptr_t token_position)
-    : script_(script),
+    : script_(Script::Handle(script.raw())),
       tokens_iterator_(TokenStream::Handle(script.tokens()), token_position),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       parsed_function_(parsed_function),
       innermost_function_(Function::Handle(parsed_function->function().raw())),
       current_class_(Class::Handle(parsed_function->function().Owner())),
       library_(Library::Handle(Class::Handle(
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
 }
 
 
+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;
 }
 
 
 const Function& Parser::current_function() const {
   ASSERT(parsed_function() != NULL);
   return parsed_function()->function();
@@ skipping 1508 matching lines @@
     if (field.is_final()) {
       ErrorMsg("final field '%s' not initialized",
                String::Handle(field.name()).ToCString());
     } else {
       field.UpdateCid(kNullCid);
     }
   }
 }
 
 
+AstNode* Parser::ParseExternalInitializedField(const Field& field) {
+  // Only use this function if the initialized field originates
+  // from a different class. We need to save and restore current
+  // class, library, and token stream (script).
+  ASSERT(current_class().raw() != field.origin());
+  const Class& saved_class = Class::Handle(current_class().raw());
+  const Library& saved_library = Library::Handle(library().raw());
+  const Script& saved_script = Script::Handle(script().raw());
+  const intptr_t saved_token_pos = TokenPos();
+
+  set_current_class(Class::Handle(field.origin()));
+  set_library(Library::Handle(current_class().library()));
+  SetScript(Script::Handle(current_class().script()), field.token_pos());
+
+  ASSERT(IsIdentifier());
+  ConsumeToken();
+  ExpectToken(Token::kASSIGN);
+  AstNode* init_expr = NULL;
+  if (field.is_const()) {
+    init_expr = ParseConstExpr();
+  } else {
+    init_expr = ParseExpr(kAllowConst, kConsumeCascades);
+    if (init_expr->EvalConstExpr() != NULL) {
+      init_expr =
+          new LiteralNode(field.token_pos(), EvaluateConstExpr(init_expr));
+    }
+  }
+  set_current_class(saved_class);
+  set_library(saved_library);
+  SetScript(saved_script, saved_token_pos);
+  return init_expr;
+}
+
+
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
   const intptr_t saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
         // again by constructors. Remember that this field is already
         // initialized.
         initialized_fields->Add(&field);
       }
-      intptr_t field_pos = field.token_pos();
+      AstNode* init_expr = NULL;
       if (current_class().raw() != field.origin()) {
-        const Class& origin_class = Class::Handle(field.origin());
-        if (origin_class.library() != library_.raw()) {
-          ErrorMsg("Cannot handle initialized mixin field '%s'"
-                   "from imported library\n", field.ToCString());
-        }
-      }
-      SetPosition(field_pos);
-      ASSERT(IsIdentifier());
-      ConsumeToken();
-      ExpectToken(Token::kASSIGN);
-
-      AstNode* init_expr = NULL;
-      if (field.is_const()) {
-        init_expr = ParseConstExpr();
+        init_expr = ParseExternalInitializedField(field);
       } else {
-        init_expr = ParseExpr(kAllowConst, kConsumeCascades);
-        if (init_expr->EvalConstExpr() != NULL) {
-          init_expr = new LiteralNode(field_pos, EvaluateConstExpr(init_expr));
+        SetPosition(field.token_pos());
+        ASSERT(IsIdentifier());
+        ConsumeToken();
+        ExpectToken(Token::kASSIGN);
+        if (field.is_const()) {
+          init_expr = ParseConstExpr();
+        } else {
+          init_expr = ParseExpr(kAllowConst, kConsumeCascades);
+          if (init_expr->EvalConstExpr() != NULL) {
+            init_expr = new LiteralNode(field.token_pos(),
+                                        EvaluateConstExpr(init_expr));
+          }
         }
       }
       ASSERT(init_expr != NULL);
       AstNode* instance = new LoadLocalNode(field.token_pos(), receiver);
       EnsureExpressionTemp();
       AstNode* field_init =
           new StoreInstanceFieldNode(field.token_pos(),
                                      instance,
                                      field,
                                      init_expr);
@@ skipping 8110 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart