Improve compile time constant evaluation

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 "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 2712 matching lines @@
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   if (current_function().is_const()) {
     if (!init_expr->IsPotentiallyConst()) {
       ReportError(expr_pos,
                   "initializer expression must be compile time constant.");
     }
     if (init_expr->EvalConstExpr() != NULL) {
       // If the expression is a compile-time constant, ensure that it
       // is evaluated and canonicalized. See issue 27164.
-      Instance& const_instance = Instance::ZoneHandle(Z);
-      if (!GetCachedConstant(expr_pos, &const_instance)) {
-        const_instance = EvaluateConstExpr(expr_pos, init_expr).raw();
-        CacheConstantValue(expr_pos, const_instance);
-      }
-      init_expr = new(Z) LiteralNode(expr_pos, const_instance);
+      init_expr = FoldConstExpr(expr_pos, init_expr);
     }
   }
   Field& field = Field::ZoneHandle(Z, cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ReportError(field_pos, "unresolved reference to instance field '%s'",
                 field_name.ToCString());
   }
   EnsureExpressionTemp();
   AstNode* instance = new(Z) LoadLocalNode(field_pos, receiver);
   AstNode* initializer = CheckDuplicateFieldInit(field_pos,
@@ skipping 56 matching lines @@
   ASSERT(IsIdentifier());
   ConsumeToken();
   ExpectToken(Token::kASSIGN);
   AstNode* init_expr = NULL;
   TokenPosition expr_pos = TokenPos();
   if (field.is_const()) {
     init_expr = ParseConstExpr();
   } else {
     init_expr = ParseExpr(kAllowConst, kConsumeCascades);
     if (init_expr->EvalConstExpr() != NULL) {
-      Instance& expr_value = Instance::ZoneHandle(Z);
-      if (!GetCachedConstant(expr_pos, &expr_value)) {
-        expr_value = EvaluateConstExpr(expr_pos, init_expr).raw();
-        CacheConstantValue(expr_pos, expr_value);
-      }
-      init_expr = new(Z) LiteralNode(field.token_pos(), expr_value);
+      init_expr = FoldConstExpr(expr_pos, init_expr);
     }
   }
   set_library(saved_library);
   SetScript(saved_script, saved_token_pos);
   return init_expr;
 }
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
@@ skipping 22 matching lines @@
         ConsumeToken();
         ExpectToken(Token::kASSIGN);
         if (current_class().is_const()) {
           // If the class has a const contructor, the initializer
           // expression must be a compile-time constant.
           init_expr = ParseConstExpr();
         } else {
           TokenPosition expr_pos = TokenPos();
           init_expr = ParseExpr(kAllowConst, kConsumeCascades);
           if (init_expr->EvalConstExpr() != NULL) {
-            Instance& expr_value = Instance::ZoneHandle(Z);
-            if (!GetCachedConstant(expr_pos, &expr_value)) {
-              expr_value = EvaluateConstExpr(expr_pos, init_expr).raw();
-              CacheConstantValue(expr_pos, expr_value);
-            }
-            init_expr = new(Z) LiteralNode(field.token_pos(), expr_value);
+            init_expr = FoldConstExpr(expr_pos, 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,
@@ skipping 8147 matching lines @@
     if ((rhs_literal == NULL) && (lhs_literal != NULL)) {
       // Swap.
       LiteralNode* temp = rhs_literal;
       rhs_literal = lhs_literal;
       lhs_literal = temp;
     }
   }
   if (binary_op == Token::kIFNULL) {
     // Handle a ?? b.
     if ((lhs->EvalConstExpr() != NULL) && (rhs->EvalConstExpr() != NULL)) {
-      Instance& expr_value = Instance::ZoneHandle(Z);
-      if (!GetCachedConstant(op_pos, &expr_value)) {
-        expr_value = EvaluateConstExpr(lhs->token_pos(), lhs).raw();
-        if (expr_value.IsNull()) {
-          expr_value = EvaluateConstExpr(rhs->token_pos(), rhs).raw();
-        }
-        CacheConstantValue(op_pos, expr_value);
+      Instance& expr_value = Instance::ZoneHandle(Z,
+          EvaluateConstExpr(lhs->token_pos(), lhs).raw());
+      if (expr_value.IsNull()) {
+        expr_value = EvaluateConstExpr(rhs->token_pos(), rhs).raw();
       }
       return new(Z) LiteralNode(op_pos, expr_value);
     }
 
     LetNode* result = new(Z) LetNode(op_pos);
     LocalVariable* left_temp = result->AddInitializer(lhs);
     left_temp->set_is_final();
     const TokenPosition no_pos = TokenPosition::kNoSource;
     LiteralNode* null_operand =
         new(Z) LiteralNode(no_pos, Object::null_instance());
@@ skipping 57 matching lines @@
 
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 LiteralNode* Parser::FoldConstExpr(TokenPosition expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode();
   }
   if (expr->EvalConstExpr() == NULL) {
     ReportError(expr_pos, "expression is not a valid compile-time constant");
   }
-  return new(Z) LiteralNode(
-      expr_pos, EvaluateConstExpr(expr_pos, expr));
+  return new(Z) LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
 
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   TokenPosition token_pos = node->token_pos();
   LetNode* result = new(Z) LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
@@ skipping 240 matching lines @@
       return new(Z) LiteralNode(expr_pos, existing_const);
     }
   }
 
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
-      const bool use_cache = !expr->IsLiteralNode();
-      LiteralNode* const_value = FoldConstExpr(expr_pos, expr);
-      if (use_cache) CacheConstantValue(expr_pos, const_value->literal());
-      expr = const_value;
+      expr = FoldConstExpr(expr_pos, expr);
     } else {
       expr = LiteralIfStaticConst(Z, expr);
     }
     return expr;
   }
   // Assignment expressions.
   if (!IsLegalAssignableSyntax(expr, TokenPos())) {
     ReportError(expr_pos, "expression is not assignable");
   }
   const Token::Kind assignment_op = CurrentToken();
@@ skipping 1074 matching lines @@
 
 
 void Parser::CacheConstantValue(TokenPosition token_pos,
                                 const Instance& value) {
   if (current_function().kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return;
   }
   InsertCachedConstantValue(script_, token_pos, value);
+  INC_STAT(thread_, num_cached_consts, 1);
 }
 
 
 bool Parser::GetCachedConstant(TokenPosition token_pos, Instance* value) {
   bool is_present = false;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     return false;
   }
   ConstantsMap constants(script_.compile_time_constants());
@@ skipping 1983 matching lines @@
       expr->AsLoadLocalNode()->local().IsConst()) {
     return *expr->AsLoadLocalNode()->local().ConstValue();
   } else if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     // We already checked that this field is const and has been
     // initialized.
     ASSERT(field.is_const());
     ASSERT(field.StaticValue() != Object::sentinel().raw());
     ASSERT(field.StaticValue() != Object::transition_sentinel().raw());
     return Instance::ZoneHandle(Z, field.StaticValue());
+  } else if (expr->IsTypeNode()) {
+    AbstractType& type =
+        AbstractType::ZoneHandle(Z, expr->AsTypeNode()->type().raw());
+    ASSERT(type.IsInstantiated() && !type.IsMalformedOrMalbounded());
+    return type;
+  } else if (expr->IsClosureNode()) {
+    const Function& func = expr->AsClosureNode()->function();
+    ASSERT((func.IsImplicitStaticClosureFunction()));
+    Instance& closure = Instance::ZoneHandle(Z, func.ImplicitStaticClosure());
+    closure = TryCanonicalize(closure, expr_pos);
+    return closure;
   } else {
     ASSERT(expr->EvalConstExpr() != NULL);
-    ReturnNode* ret = new(Z) ReturnNode(expr->token_pos(), expr);
+    Instance& value = Instance::ZoneHandle(Z);
+    if (GetCachedConstant(expr_pos, &value)) {
+      return value;
+    }
+    ReturnNode* ret = new(Z) ReturnNode(expr_pos, expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new(Z) LocalScope(NULL, 0, 0);
-    SequenceNode* seq = new(Z) SequenceNode(expr->token_pos(), empty_scope);
+    SequenceNode* seq = new(Z) SequenceNode(expr_pos, empty_scope);
     seq->Add(ret);
 
+    INC_STAT(thread_, num_execute_const, 1);
     Object& result = Object::Handle(Z, Compiler::ExecuteOnce(seq));
     if (result.IsError()) {
       ReportErrors(Error::Cast(result),
                    script_, expr_pos,
                    "error evaluating constant expression");
     }
     ASSERT(result.IsInstance() || result.IsNull());
-    Instance& value = Instance::ZoneHandle(Z);
     value ^= result.raw();
-    value = TryCanonicalize(value, TokenPos());
+    value = TryCanonicalize(value, expr_pos);
+    CacheConstantValue(expr_pos, value);
     return value;
   }
 }
 
 
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
       SkipType(true);
     }
@@ skipping 446 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME