Partial solution to analyze potentially constant expressions

runtime/vm/ast.cc

 // Copyright (c) 2011, 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/ast.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
@@ skipping 92 matching lines @@
 }
 
 
 void ArrayNode::VisitChildren(AstNodeVisitor* visitor) const {
   for (intptr_t i = 0; i < this->length(); i++) {
     ElementAt(i)->Visit(visitor);
   }
 }
 
 
+bool LiteralNode::IsPotentiallyConst() const {
+  return true;
+}
+
+
 // TODO(srdjan): Add code for logical negation.
 AstNode* LiteralNode::ApplyUnaryOp(Token::Kind unary_op_kind) {
   if (unary_op_kind == Token::kNEGATE) {
     if (literal().IsSmi()) {
       const Smi& smi = Smi::Cast(literal());
       const Instance& literal =
           Instance::ZoneHandle(Integer::New(-smi.Value()));
       return new LiteralNode(this->token_pos(), literal);
     }
     if (literal().IsDouble()) {
@@ skipping 15 matching lines @@
       || Token::IsTypeTestOperator(kind_)
       || Token::IsTypeCastOperator(kind_);
 }
 
 
 const char* ComparisonNode::Name() const {
   return Token::Str(kind_);
 }
 
 
+bool ComparisonNode::IsPotentiallyConst() const {
+  switch (kind_) {
+    case Token::kLT:
+    case Token::kGT:
+    case Token::kLTE:
+    case Token::kGTE:
+    case Token::kEQ:
+    case Token::kNE:
+    case Token::kEQ_STRICT:
+    case Token::kNE_STRICT:
+      return this->left()->IsPotentiallyConst() &&
+          this->right()->IsPotentiallyConst();
+    default:
+      return false;
+  }
+}
+
+
 const Instance* ComparisonNode::EvalConstExpr() const {
   const Instance* left_val = this->left()->EvalConstExpr();
   if (left_val == NULL) {
     return NULL;
   }
   const Instance* right_val = this->right()->EvalConstExpr();
   if (right_val == NULL) {
     return NULL;
   }
   switch (kind_) {
@@ skipping 51 matching lines @@
       return false;
   }
 }
 
 
 const char* BinaryOpNode::Name() const {
   return Token::Str(kind_);
 }
 
 
+bool BinaryOpNode::IsPotentiallyConst() const {
+  switch (kind_) {
+    case Token::kADD:
+    case Token::kSUB:
+    case Token::kMUL:
+    case Token::kDIV:
+    case Token::kMOD:
+    case Token::kTRUNCDIV:
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
+    case Token::kBIT_AND:
+    case Token::kSHL:
+    case Token::kSHR:
+    case Token::kOR:
+    case Token::kAND:
+      return this->left()->IsPotentiallyConst() &&
+          this->right()->IsPotentiallyConst();
+    default:
+      UNREACHABLE();
+      return false;
+  }
+}
+
+
 const Instance* BinaryOpNode::EvalConstExpr() const {
   const Instance* left_val = this->left()->EvalConstExpr();
   if (left_val == NULL) {
     return NULL;
   }
   if (!left_val->IsNumber() && !left_val->IsBool()) {
     return NULL;
   }
   const Instance* right_val = this->right()->EvalConstExpr();
   if (right_val == NULL) {
@@ skipping 47 matching lines @@
   AstNode* new_operand = operand->ApplyUnaryOp(kind);
   if (new_operand != NULL) {
     return new_operand;
   }
   return new UnaryOpNode(token_pos, kind, operand);
 }
 
 
 bool UnaryOpNode::IsKindValid() const {
   switch (kind_) {
     case Token::kADD:

[Ivan Posva, 2013/07/03 20:23:42]

Still legal?

[hausner, 2013/07/03 21:20:54]

Historical artifact that I should have removed with the elimination of unary
plus a couple of weeks ago. Removed.

     case Token::kNEGATE:
     case Token::kNOT:
     case Token::kBIT_NOT:
       return true;
     default:
       return false;
   }
 }
 
 
+bool UnaryOpNode::IsPotentiallyConst() const {
+  return true;

[Ivan Posva, 2013/07/03 20:23:42]

Shouldn't the operand also be potentially const?

[hausner, 2013/07/03 21:20:54]

Actually, yes. Fixed.

+}
+
+
 const Instance* UnaryOpNode::EvalConstExpr() const {
   const Instance* val = this->operand()->EvalConstExpr();
   if (val == NULL) {
     return NULL;
   }
   switch (kind_) {
     case Token::kADD:
     case Token::kNEGATE:
       return val->IsNumber() ? val : NULL;
     case Token::kNOT:
       return val->IsBool() ? val : NULL;
     case Token::kBIT_NOT:
       return val->IsInteger() ? val : NULL;
     default:
       return NULL;
   }
 }
 
 
+bool ClosureNode::IsPotentiallyConst() const {
+  if (function().IsImplicitStaticClosureFunction()) {
+    return true;
+  }
+  return false;
+}
+
+
 const Instance* ClosureNode::EvalConstExpr() const {
   if (function().IsImplicitStaticClosureFunction()) {
     // Return a value that represents an instance. Only the type is relevant.
     return &Instance::Handle();
   }
   return NULL;
 }
 
 
 AstNode* ClosureNode::MakeAssignmentNode(AstNode* rhs) {
@@ skipping 14 matching lines @@
 const char* UnaryOpNode::Name() const {
   return Token::Str(kind_);
 }
 
 
 const char* JumpNode::Name() const {
   return Token::Str(kind_);
 }
 
 
+bool LoadLocalNode::IsPotentiallyConst() const {
+  return true;

[Ivan Posva, 2013/07/03 20:23:42]

Really? Thanks for the offline explanation, it would be helpful to have it here
as a comment. Even more helpful would be if we could somehow assert that we are
only accessing parameters in the context of const constructor initializer
expressions. Not sure how to do that though.

[hausner, 2013/07/03 21:20:54]

Added comment and checked that the local variable/parameter is final.

+}
+
+
 const Instance* LoadLocalNode::EvalConstExpr() const {
   if (local().IsConst()) {
     return local().ConstValue();
   }
   return NULL;
 }
 
 
 AstNode* LoadLocalNode::MakeAssignmentNode(AstNode* rhs) {
   if (local().is_final()) {
@@ skipping 80 matching lines @@
   const String& cls_name = String::Handle(cls.Name());
   const String& func_name = String::Handle(function().name());
   if (cls_name.Equals(Symbols::NoSuchMethodError()) &&
       func_name.StartsWith(Symbols::ThrowNew())) {
     return this;
   }
   return NULL;
 }
 
 
+bool StaticGetterNode::IsPotentiallyConst() const {
+  const String& getter_name =
+      String::Handle(Field::GetterName(this->field_name()));
+  const Function& getter_func =
+      Function::Handle(this->cls().LookupStaticFunction(getter_name));
+  if (getter_func.IsNull() || !getter_func.is_const()) {
+    return false;
+  }
+  return true;
+}
+
+
 const Instance* StaticGetterNode::EvalConstExpr() const {
   const String& getter_name =
       String::Handle(Field::GetterName(this->field_name()));
   const Function& getter_func =
       Function::Handle(this->cls().LookupStaticFunction(getter_name));
   if (getter_func.IsNull() || !getter_func.is_const()) {
     return NULL;
   }
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(getter_func, Object::empty_array()));
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   return &Instance::ZoneHandle(Instance::Cast(result).raw());
 }
 
 }  // namespace dart