Implement deferred constant support

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1989 matching lines @@
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
-AstNode* Parser::CreateImplicitClosureNode(const Function& func,
-                                           intptr_t token_pos,
-                                           AstNode* receiver) {
+ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
+                                               intptr_t token_pos,
+                                               AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
       const Class& signature_class = Class::Handle(
           implicit_closure_function.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
@@ skipping 6010 matching lines @@
       ErrorMsg("expression expected after throw");
     }
     AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
     return new ThrowNode(expr_pos, expr, NULL);
   }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
-    expr = LiteralIfStaticConst(expr);
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
+    } else {
+      expr = LiteralIfStaticConst(expr);
     }
     return expr;
   }
   // Assignment expressions.
   if (!IsLegalAssignableSyntax(expr, TokenPos())) {
     ErrorMsg(expr_pos, "expression is not assignable");
   }
   const Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = TokenPos();
   ConsumeToken();
@@ skipping 329 matching lines @@
     // for a field (which may be defined in a subclass.)
     // In metadata, an unresolved identifier cannot be a compile-time constant.
     String& name = String::CheckedZoneHandle(primary->primary().raw());
     if (parsing_metadata_) {
       ErrorMsg(primary->token_pos(),
                "unresolved identifier '%s' is not a compile-time constant",
                name.ToCString());
     }
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
-      return new StaticGetterNode(primary->token_pos(),
-                                  NULL,  // No receiver.
-                                  false,  // Not a super getter.
-                                  Class::ZoneHandle(current_class().raw()),
-                                  name);
+      StaticGetterNode* getter =
+          new StaticGetterNode(primary->token_pos(),
+                               NULL,  // No receiver.
+                               false,  // Not a super getter.
+                               Class::ZoneHandle(current_class().raw()),
+                               name);
+      getter->set_is_deferred(primary->is_deferred_reference());
+      return getter;
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
 
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
   ASSERT(primary->primary().IsFunction());
-  AstNode* closure = NULL;
   const Function& func =
       Function::CheckedZoneHandle(primary->primary().raw());
   const String& funcname = String::ZoneHandle(func.name());
   if (func.is_static()) {
     // Static function access.
-    closure = CreateImplicitClosureNode(func, primary->token_pos(), NULL);
+    ClosureNode* closure =
+        CreateImplicitClosureNode(func, primary->token_pos(), NULL);
+    closure->set_is_deferred(primary->is_deferred_reference());
+    return closure;
   } else {
     // Instance function access.
     if (parsing_metadata_) {
       ErrorMsg(primary->token_pos(),
                "cannot access instance method '%s' from metadata",
                funcname.ToCString());
     }
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       ErrorMsg(primary->token_pos(),
                "cannot access instance method '%s' from static method",
                funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
-    closure = CallGetter(primary->token_pos(), receiver, funcname);
+    return CallGetter(primary->token_pos(), receiver, funcname);
   }
-  return closure;
+  UNREACHABLE();
+  return NULL;
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
@@ skipping 808 matching lines @@
   if (prefix.is_loaded()) {
     obj = prefix.LookupObject(ident);
   } else {
     // Remember that this function depends on an import prefix of an
     // unloaded deferred library. Note that parsed_function() can be
     // NULL when parsing expressions outside the scope of a function.
     if (parsed_function() != NULL) {
       parsed_function()->AddDeferredPrefix(prefix);
     }
   }
+  const bool is_deferred = prefix.is_deferred_load();
   if (obj.IsNull()) {
     // Unresolved prefixed primary identifier.
     return NULL;
   } else if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+    PrimaryNode* primary =
+        new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
+    primary->set_is_deferred(is_deferred);
+    return primary;
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
-    return GenerateStaticFieldLookup(field, ident_pos);
+    AstNode* get_field = GenerateStaticFieldLookup(field, ident_pos);
+    ASSERT(get_field != NULL);
+    ASSERT(get_field->IsLoadStaticFieldNode() ||
+           get_field->IsStaticGetterNode());
+    if (get_field->IsLoadStaticFieldNode()) {
+      get_field->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
+    } else if (get_field->IsStaticGetterNode()) {
+      get_field->AsStaticGetterNode()->set_is_deferred(is_deferred);
+    }
+    return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
-      return new StaticGetterNode(ident_pos,
-                                  /* receiver */ NULL,
-                                  /* is_super_getter */ false,
-                                  Class::ZoneHandle(func.Owner()),
-                                  ident);
-
+      StaticGetterNode* getter =
+          new StaticGetterNode(ident_pos,
+                               /* receiver */ NULL,
+                               /* is_super_getter */ false,
+                               Class::ZoneHandle(func.Owner()),
+                               ident);
+      getter->set_is_deferred(is_deferred);
+      return getter;
     } else {
-      return new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+      PrimaryNode* primary =
+          new PrimaryNode(ident_pos, Function::ZoneHandle(func.raw()));
+      primary->set_is_deferred(is_deferred);
+      return primary;
     }
   }
   // All possible object types are handled above.
   UNREACHABLE();
   return NULL;
 }
 
 
 // Resolve identifier. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
@@ skipping 1585 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart