Collect type feedback for fields.

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 969 matching lines @@
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(ident_pos, current_block_->scope->VariableAt(1));
 
+  EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value);
-
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(ident_pos));
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
   ParamList params;
 
@@ skipping 781 matching lines @@
   }
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ErrorMsg(field_pos, "unresolved reference to instance field '%s'",
              field_name.ToCString());
   }
   CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
   AstNode* instance = new LoadLocalNode(field_pos, receiver);
+  EnsureExpressionTemp();
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckConstFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
-    if (field.is_static() || !field.is_final()) {
+    if (field.is_static()) {
       continue;
     }
+
     bool found = false;
     for (int i = 0; i < initializers->length(); i++) {
       found = false;
       if (initializers->NodeAt(i)->IsStoreInstanceFieldNode()) {
         StoreInstanceFieldNode* initializer =
             initializers->NodeAt(i)->AsStoreInstanceFieldNode();
         if (initializer->field().raw() == field.raw()) {
           found = true;
           break;
         }
       }
     }
-    if (!found) {
+
+    if (found) continue;
+
+    if (field.is_final()) {
       ErrorMsg("final field '%s' not initialized",
                String::Handle(field.name()).ToCString());
+    } else {
+      field.UpdateCid(kNullCid);
     }
   }
 }
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
@@ skipping 27 matching lines @@
       if (field.is_const()) {
         init_expr = ParseConstExpr();
       } else {
         init_expr = ParseExpr(kAllowConst, kConsumeCascades);
         if (init_expr->EvalConstExpr() != NULL) {
           init_expr = new LiteralNode(field_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);
       current_block_->statements->Add(field_init);
     }
   }
   SetPosition(saved_pos);
 }
@@ skipping 232 matching lines @@
         CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
         AstNode* instance = new LoadLocalNode(param.name_pos, receiver);
         LocalVariable* p =
             current_block_->scope->LookupVariable(*param.name, false);
         ASSERT(p != NULL);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, make the parameter invisible.
         p->set_invisible(true);
         AstNode* value = new LoadLocalNode(param.name_pos, p);
+        EnsureExpressionTemp();
         AstNode* initializer = new StoreInstanceFieldNode(
             param.name_pos, instance, field, value);
         current_block_->statements->Add(initializer);
       }
     }
   }
 
   // Now parse the explicit initializer list or constructor redirection.
   ParseInitializers(cls, receiver, &initialized_fields);
 
@@ skipping 7938 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart