Associate the correct type to method receivers (instead of Dynamic type).

runtime/vm/ast.h

 // 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.
 
 #ifndef VM_AST_H_
 #define VM_AST_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
@@ skipping 290 matching lines @@
   GrowableArray<AstNode*> elements_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayNode);
 };
 
 
 class LiteralNode : public AstNode {
  public:
   LiteralNode(intptr_t token_pos, const Instance& literal)
       : AstNode(token_pos), literal_(literal) {
-    ASSERT(literal.IsZoneHandle());
-    ASSERT(literal.IsSmi() || literal.IsOld());
+    ASSERT(literal_.IsZoneHandle());
+    ASSERT(literal_.IsSmi() || literal_.IsOld());
 #if defined(DEBUG)
-    if (literal.IsString()) {
-      ASSERT(String::Cast(literal).IsSymbol());
+    if (literal_.IsString()) {
+      ASSERT(String::Cast(literal_).IsSymbol());
     }
 #endif  // defined(DEBUG)
-    ASSERT(literal.IsNull() ||
-           Class::Handle(literal.clazz()).is_finalized() ||
-           Class::Handle(literal.clazz()).is_prefinalized());
+    ASSERT(literal_.IsNull() ||
+           Class::Handle(literal_.clazz()).is_finalized() ||
+           Class::Handle(literal_.clazz()).is_prefinalized());
   }
 
   const Instance& literal() const { return literal_; }
 
   virtual const Instance* EvalConstExpr() const {
     return &literal();
   }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   virtual AstNode* ApplyUnaryOp(Token::Kind unary_op_kind);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LiteralNode);
 
  private:
   const Instance& literal_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LiteralNode);
 };
 
 
 class TypeNode : public AstNode {
  public:
   TypeNode(intptr_t token_pos, const AbstractType& type)
       : AstNode(token_pos), type_(type) {
-    ASSERT(type.IsZoneHandle());
-    ASSERT(!type.IsNull());
-    ASSERT(type.IsFinalized());
+    ASSERT(type_.IsZoneHandle());
+    ASSERT(!type_.IsNull());
+    ASSERT(type_.IsFinalized());
   }
 
   const AbstractType& type() const { return type_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   DECLARE_COMMON_NODE_FUNCTIONS(TypeNode);
 
  private:
   const AbstractType& type_;
@@ skipping 38 matching lines @@
 class ClosureNode : public AstNode {
  public:
   ClosureNode(intptr_t token_pos,
               const Function& function,
               AstNode* receiver,  // Non-null for implicit instance closures.
               LocalScope* scope)  // Null for implicit closures.
       : AstNode(token_pos),
         function_(function),
         receiver_(receiver),
         scope_(scope) {
-    ASSERT(function.IsZoneHandle());
-    ASSERT((function.IsNonImplicitClosureFunction() &&
+    ASSERT(function_.IsZoneHandle());
+    ASSERT((function_.IsNonImplicitClosureFunction() &&
             (receiver_ == NULL) && (scope_ != NULL)) ||
-           (function.IsImplicitInstanceClosureFunction() &&
+           (function_.IsImplicitInstanceClosureFunction() &&
             (receiver_ != NULL) && (scope_ == NULL)) ||
-           (function.IsImplicitStaticClosureFunction() &&
+           (function_.IsImplicitStaticClosureFunction() &&
             (receiver_ == NULL) && (scope_ == NULL)));
   }
 
   const Function& function() const { return function_; }
   AstNode* receiver() const { return receiver_; }
   LocalScope* scope() const { return scope_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     if (receiver() != NULL) {
       receiver()->Visit(visitor);
@@ skipping 12 matching lines @@
 
 
 // Primary nodes hold identifiers or values (library, class or function)
 // resolved from an identifier. Primary nodes should not ever make it to the
 // code generation phase as they will be transformed into the correct call or
 // field access nodes.
 class PrimaryNode : public AstNode {
  public:
   PrimaryNode(intptr_t token_pos, const Object& primary)
       : AstNode(token_pos), primary_(primary) {
-    ASSERT(primary.IsZoneHandle());
+    ASSERT(primary_.IsZoneHandle());
   }
 
   const Object& primary() const { return primary_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(PrimaryNode);
 
  private:
   const Object& primary_;
@@ skipping 466 matching lines @@
   Token::Kind kind_;
   SourceLabel* label_;
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(JumpNode);
 };
 
 
 class LoadLocalNode : public AstNode {
  public:
   LoadLocalNode(intptr_t token_pos, const LocalVariable& local)
-      : AstNode(token_pos), local_(local), pseudo_(NULL) { }
+      : AstNode(token_pos), local_(local), pseudo_(NULL) {
+    ASSERT(&local_ != NULL);

[srdjan, 2012/08/02 22:29:46]

That can't be, can it? You can't pass *NULL to it?
Ditto for cases below.

[regis, 2012/08/02 23:01:26]

Actually, yes, you can pass *receiver with receiver == NULL. It just happened to
me while debugging this cl. It's why I added the assert.

+  }
   // The pseudo node does not produce input but must be visited before
   // completing local load.
   LoadLocalNode(intptr_t token_pos,
                 const LocalVariable& local,
                 AstNode* pseudo)
-      : AstNode(token_pos), local_(local), pseudo_(pseudo) {}
+      : AstNode(token_pos), local_(local), pseudo_(pseudo) {
+    ASSERT(&local_ != NULL);
+  }
 
   const LocalVariable& local() const { return local_; }
   AstNode* pseudo() const { return pseudo_; }  // Can be NULL.
   bool HasPseudo() const { return pseudo_ != NULL; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     if (HasPseudo()) {
       pseudo()->Visit(visitor);
     }
   }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadLocalNode);
 
  private:
   const LocalVariable& local_;
   AstNode* pseudo_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadLocalNode);
 };
 
 
 class StoreLocalNode : public AstNode {
  public:
   StoreLocalNode(intptr_t token_pos,
                  const LocalVariable& local,
                  AstNode* value)
       : AstNode(token_pos), local_(local), value_(value) {
+    ASSERT(&local_ != NULL);
     ASSERT(value_ != NULL);
   }
 
   const LocalVariable& local() const { return local_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreLocalNode);
 
  private:
   const LocalVariable& local_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreLocalNode);
 };
 
 
 
 class LoadInstanceFieldNode : public AstNode {
  public:
   LoadInstanceFieldNode(intptr_t token_pos,
                         AstNode* instance,
                         const Field& field)
       : AstNode(token_pos), instance_(instance), field_(field) {
     ASSERT(instance_ != NULL);
-    ASSERT(field.IsZoneHandle());
+    ASSERT(field_.IsZoneHandle());
   }
 
   AstNode* instance() const { return instance_; }
   const Field& field() const { return field_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     instance()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadInstanceFieldNode);
@@ skipping 10 matching lines @@
  public:
   StoreInstanceFieldNode(intptr_t token_pos,
                          AstNode* instance,
                          const Field& field,
                          AstNode* value)
       : AstNode(token_pos),
         instance_(instance),
         field_(field),
         value_(value) {
     ASSERT(instance_ != NULL);
-    ASSERT(field.IsZoneHandle());
+    ASSERT(field_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   AstNode* instance() const { return instance_; }
   const Field& field() const { return field_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     instance()->Visit(visitor);
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreInstanceFieldNode);
 
  private:
   AstNode* instance_;
   const Field& field_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreInstanceFieldNode);
 };
 
 
 class LoadStaticFieldNode : public AstNode {
  public:
   LoadStaticFieldNode(intptr_t token_pos, const Field& field)
       : AstNode(token_pos), field_(field) {
-    ASSERT(field.IsZoneHandle());
+    ASSERT(field_.IsZoneHandle());
   }
 
   const Field& field() const { return field_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const { }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   virtual const Instance* EvalConstExpr() const {
     ASSERT(field_.is_static());
     return field_.is_final() ? &Instance::ZoneHandle(field_.value()) : NULL;
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadStaticFieldNode);
 
  private:
   const Field& field_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadStaticFieldNode);
 };
 
 
 class StoreStaticFieldNode : public AstNode {
  public:
   StoreStaticFieldNode(intptr_t token_pos, const Field& field, AstNode* value)
       : AstNode(token_pos), field_(field), value_(value) {
-    ASSERT(field.IsZoneHandle());
+    ASSERT(field_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   const Field& field() const { return field_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
@@ skipping 242 matching lines @@
 
 
 class StaticCallNode : public AstNode {
  public:
   StaticCallNode(intptr_t token_pos,
                  const Function& function,
                  ArgumentListNode* arguments)
       : AstNode(token_pos),
         function_(function),
         arguments_(arguments) {
-    ASSERT(function.IsZoneHandle());
+    ASSERT(function_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
   const Function& function() const { return function_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     arguments()->Visit(visitor);
   }
 
@@ skipping 298 matching lines @@
   const LocalVariable& context_var_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InlinedFinallyNode);
 };
 
 }  // namespace dart
 
 #undef DECLARE_COMMON_NODE_FUNCTIONS
 
 #endif  // VM_AST_H_