Handle type literals correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678

[email protected]

Review-Url: https://codereview.chromium.org/2683973002 .

Author: fsc8000

runtime/vm/ast.h

@@ -443,8 +443,12 @@ class LiteralNode : public AstNode {
 
 class TypeNode : public AstNode {
  public:
-  TypeNode(TokenPosition token_pos, const AbstractType& type)
-      : AstNode(token_pos), type_(type) {
+  TypeNode(TokenPosition token_pos,
+           const AbstractType& type,
+           bool is_deferred_reference = false)
+      : AstNode(token_pos),
+        type_(type),
+        is_deferred_reference_(is_deferred_reference) {
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
@@ -466,10 +470,14 @@ class TypeNode : public AstNode {
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
+  bool is_deferred_reference() const { return is_deferred_reference_; }
+  void set_is_deferred_reference(bool value) { is_deferred_reference_ = value; }
+
   DECLARE_COMMON_NODE_FUNCTIONS(TypeNode);
 
  private:
   const AbstractType& type_;
+  bool is_deferred_reference_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeNode);
 };

runtime/vm/ast_transformer.cc

@@ -119,7 +119,14 @@ void AwaitTransformer::VisitLiteralNode(LiteralNode* node) {
 
 
 void AwaitTransformer::VisitTypeNode(TypeNode* node) {
-  result_ = new (Z) TypeNode(node->token_pos(), node->type());
+  if (node->is_deferred_reference()) {
+    // Deferred references must use a temporary even after loading
+    // happened, so that the number of await temps is the same as
+    // before the loading.
+    result_ = MakeName(node);
+  } else {
+    result_ = node;
+  }
 }
 
 

runtime/vm/parser.cc

@@ -11837,7 +11837,8 @@ AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
           type ^= CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          array = new (Z) TypeNode(primary_pos, type);
+          array = new (Z) TypeNode(primary_pos, type,
+                                   primary_node->is_deferred_reference());
         } else if (primary_node->primary().IsTypeParameter()) {
           array = LoadTypeParameter(primary_node);
         } else {
@@ -11931,7 +11932,8 @@ AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
           type ^= CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          selector = new (Z) TypeNode(primary_pos, type);
+          selector = new (Z) TypeNode(primary_pos, type,
+                                      primary_node->is_deferred_reference());
         } else {
           UNREACHABLE();  // Internal parser error.
         }
@@ -11957,7 +11959,8 @@ AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
           type = CanonicalizeType(type);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          left = new (Z) TypeNode(primary_pos, type);
+          left = new (Z) TypeNode(primary_pos, type,
+                                  primary_node->is_deferred_reference());
         } else if (primary_node->primary().IsTypeParameter()) {
           left = LoadTypeParameter(primary_node);
         } else if (primary_node->IsSuper()) {
@@ -12878,7 +12881,8 @@ AstNode* Parser::ResolveIdent(TokenPosition ident_pos,
       type ^= CanonicalizeType(type);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
-      resolved = new (Z) TypeNode(primary_pos, type);
+      resolved =
+          new (Z) TypeNode(primary_pos, type, primary->is_deferred_reference());
     }
   }
   return resolved;

tests/language/deferred_regression_28678_lib.dart

@@ -0,0 +1,7 @@
+// Copyright (c) 2017, 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.
+
+var v;
+
+class Clazz { }

tests/language/deferred_regression_28678_test.dart

@@ -0,0 +1,28 @@
+// Copyright (c) 2017, 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.
+
+// Test that await after deferred loading works as expected.
+
+import 'dart:async';
+import "package:expect/expect.dart";
+import 'deferred_regression_28678_lib.dart' deferred as lib;
+
+class A {
+  m() => "here";
+}
+
+f(a, b) => new Future.microtask(() {});
+
+class R {
+  Future test_deferred() async {
+    var a = new A();
+    await lib.loadLibrary();
+    await f(lib.Clazz, lib.v);
+    Expect.equals("here", a.m());
+  }
+}
+
+main() async {
+  await new R().test_deferred();
+}