Source positions for constructors and lots of async machinery

runtime/vm/flow_graph_builder_test.cc

 // Copyright (c) 2016, 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/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/unit_test.h"
@@ skipping 77 matching lines @@
             count++;
           }
         } else {
           count++;
         }
       }
     }
     DUMP_ASSERT(count > 0);
   }
 
+  // Expect to find an instance call at |line| and |column|.
+  void InstanceCallAt(intptr_t line,

[rmacnak, 2016/01/14 00:28:08]

Nit: the argument order here is different from StaticCallAt

[Cutch, 2016/01/14 15:25:10]

Done.

+                      intptr_t column,
+                      const char* needle) {
+    ZoneGrowableArray<Instruction*>* instructions =
+        FindInstructionsAt(line, column);
+    intptr_t count = 0;
+    for (intptr_t i = 0; i < instructions->length(); i++) {
+      Instruction* instr = instructions->At(i);
+      EXPECT(instr != NULL);
+      if (instr->IsInstanceCall()) {
+        const char* haystack = instr->ToCString();
+        if (strstr(haystack, needle) != NULL) {
+          count++;
+        }
+      }
+    }
+    DUMP_ASSERT(count > 0);
+  }
+
   // Expect to find at least one static call at |line| and |column|. The
   // static call will have |needle| in its |ToCString| representation.
   void StaticCallAt(const char* needle,
                     intptr_t line,
                     intptr_t column = -1) {
     ZoneGrowableArray<Instruction*>* instructions =
         FindInstructionsAt(line, column);
     intptr_t count = 0;
     for (intptr_t i = 0; i < instructions->length(); i++) {
       Instruction* instr = instructions->At(i);
@@ skipping 31 matching lines @@
     for (intptr_t i = 0; i < blocks_->length(); i++) {
       BlockEntryInstr* entry = (*blocks_)[i];
       THR_Print("B%" Pd ":\n", entry->block_id());
       DumpInstruction(entry);
       for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
         DumpInstruction(it.Current());
       }
     }
   }
 
+  // Fails if any of the IR nodes has a token position of Scanner::kNoSourcePos.
+  void EnsureSourcePositions() {
+    for (intptr_t i = 0; i < blocks_->length(); i++) {
+      BlockEntryInstr* entry = (*blocks_)[i];
+      DUMP_ASSERT(entry->token_pos() != Scanner::kNoSourcePos);
+      for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
+        Instruction* instr = it.Current();
+        DUMP_ASSERT(instr->token_pos() != Scanner::kNoSourcePos);
+      }
+    }
+  }
+
  private:
   void DumpInstruction(Instruction* instr) {
     const intptr_t token_pos = instr->token_pos();
     if (token_pos < 0) {
       const char* token_pos_string =
           ClassifyingTokenPositions::ToCString(token_pos);
       THR_Print("%12s -- %s\n", token_pos_string, instr->ToCString());
       return;
     }
     intptr_t token_line = -1;
@@ skipping 101 matching lines @@
       "  return z;\n"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
   spt.InstanceCallAt(4, 13, Token::kADD);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 5, 3);
   spt.FuzzyInstructionMatchAt("Return", 5, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_If) {
   const char* kScript =
       "var x = 5;\n"
       "var y = 5;\n"
       "main() {\n"
       "  if (x != 0) {\n"
       "    return x;\n"
       "  }\n"
       "  return y;\n"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 4, 7);
   spt.InstanceCallAt(4, 9, Token::kEQ);
   spt.FuzzyInstructionMatchAt("Branch if StrictCompare", 4, 9);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 5, 12);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 5, 5);
   spt.FuzzyInstructionMatchAt("Return", 5, 5);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 7, 10);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 7, 3);
   spt.FuzzyInstructionMatchAt("Return", 7, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_ForLoop) {
   const char* kScript =
       "var x = 0;\n"
       "var y = 5;\n"
       "main() {\n"
       "  for (var i = 0; i < 10; i++) {\n"
       "    x += i;\n"
       "  }\n"
       "  return x;\n"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
   spt.FuzzyInstructionMatchAt("StoreLocal", 4, 14);
   spt.FuzzyInstructionMatchAt("LoadLocal", 4, 19);
   spt.InstanceCallAt(4, 21, Token::kLT);
   spt.FuzzyInstructionMatchAt("Branch if StrictCompare", 4, 21);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 5, 5);
   spt.FuzzyInstructionMatchAt("StoreStaticField", 5, 5);
   spt.InstanceCallAt(5, 7, Token::kADD);
   spt.FuzzyInstructionMatchAt("LoadLocal", 5, 10);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 7, 10);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 7, 3);
   spt.FuzzyInstructionMatchAt("Return", 7, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_While) {
   const char* kScript =
       "var x = 0;\n"
       "var y = 5;\n"
       "main() {\n"
       "  while (x < 10) {\n"
       "    if (y == 5) {\n"
@@ skipping 27 matching lines @@
 
   spt.FuzzyInstructionMatchAt("Constant", 8, 5);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 8, 5);
   spt.FuzzyInstructionMatchAt("Constant(#1)", 8, 6);
   spt.InstanceCallAt(8, 6, Token::kADD);
   spt.FuzzyInstructionMatchAt("StoreStaticField", 8, 5);
 
   spt.FuzzyInstructionMatchAt("LoadStaticField", 10, 10);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 10, 3);
   spt.FuzzyInstructionMatchAt("Return", 10, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_WhileContinueBreak) {
   const char* kScript =
       "var x = 0;\n"
       "var y = 5;\n"
       "main() {\n"
       "  while (x < 10) {\n"
       "    if (y == 5) {\n"
@@ skipping 18 matching lines @@
 
   spt.FuzzyInstructionMatchAt("Constant(#Field", 5, 9);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 5, 9);
   spt.FuzzyInstructionMatchAt("Constant(#5", 5, 14);
   spt.InstanceCallAt(5, 11, Token::kEQ);
   spt.FuzzyInstructionMatchAt("Branch if StrictCompare", 5, 11);
 
   spt.FuzzyInstructionMatchAt("LoadStaticField", 10, 10);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 10, 3);
   spt.FuzzyInstructionMatchAt("Return", 10, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_LoadIndexed) {
   const char* kScript =
       "var x = 0;\n"
       "var z = new List(3);\n"
       "main() {\n"
       "  z[0];\n"
       "  var y = z[0] + z[1] + z[2];\n"
@@ skipping 17 matching lines @@
 
   spt.StaticCallAt("get:z", 5, 25);
   spt.FuzzyInstructionMatchAt("Constant(#2)", 5, 27);
   spt.InstanceCallAt(5, 26, Token::kINDEX);
 
   spt.InstanceCallAt(5, 23, Token::kADD);
 
   spt.FuzzyInstructionMatchAt("Constant(#null)", 6, 1);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 6, 1);
   spt.FuzzyInstructionMatchAt("Return", 6, 1);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_StoreIndexed) {
   const char* kScript =
       "var x = 0;\n"
       "var z = new List(4);\n"
       "main() {\n"
       "  z[0];\n"
       "  z[3] = z[0] + z[1] + z[2];\n"
@@ skipping 22 matching lines @@
 
   spt.StaticCallAt("get:z", 5, 24);
   spt.FuzzyInstructionMatchAt("Constant(#2)", 5, 26);
   spt.InstanceCallAt(5, 25, Token::kINDEX);
 
   spt.InstanceCallAt(5, 4, Token::kASSIGN_INDEX);
 
   spt.FuzzyInstructionMatchAt("Constant(#null)", 6, 1);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 6, 1);
   spt.FuzzyInstructionMatchAt("Return", 6, 1);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_BitwiseOperations) {
   const char* kScript =
       "var x = 0;\n"
       "var y = 1;\n"
       "main() {\n"
       "  var z;\n"
       "  z = x & y;\n"
@@ skipping 28 matching lines @@
   spt.InstanceCallAt(7, 9, Token::kBIT_XOR);
   spt.FuzzyInstructionMatchAt("StoreLocal(z", 7, 3);
 
   spt.FuzzyInstructionMatchAt("LoadLocal(z", 8, 8);
   spt.InstanceCallAt(8, 7, Token::kBIT_NOT);
   spt.FuzzyInstructionMatchAt("StoreLocal(z", 8, 3);
 
   spt.FuzzyInstructionMatchAt("LoadLocal(z", 9, 10);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 9, 3);
   spt.FuzzyInstructionMatchAt("Return", 9, 3);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_IfElse) {
   const char* kScript =
       "var x = 5;\n"
       "var y = 5;\n"
       "main() {\n"
       "  if (x != 0) {\n"
       "    return x;\n"
       "  } else {\n"
       "    return y;\n"
       "  }\n"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 4, 7);
   spt.InstanceCallAt(4, 9, Token::kEQ);
   spt.FuzzyInstructionMatchAt("Branch if StrictCompare", 4, 9);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 5, 12);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 5, 5);
   spt.FuzzyInstructionMatchAt("Return", 5, 5);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 7, 12);
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 7, 5);
   spt.FuzzyInstructionMatchAt("Return", 7, 5);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_Switch) {
   const char* kScript =
       "var x = 5;\n"
       "var y = 5;\n"
       "main() {\n"
       "  switch (x) {\n"
       "    case 1: return 3;\n"
@@ skipping 24 matching lines @@
   spt.FuzzyInstructionMatchAt("LoadLocal(:switch_expr", 6, 5);   // 'c'
   spt.InstanceCallAt(6, 10, Token::kEQ);                         // '2'
 
   spt.FuzzyInstructionMatchAt("Constant(#4", 6, 20);             // '4'
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 6, 13);
   spt.FuzzyInstructionMatchAt("Return", 6, 13);
 
   spt.FuzzyInstructionMatchAt("Constant(#5", 7, 21);             // '5'
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 7, 14);
   spt.FuzzyInstructionMatchAt("Return", 7, 14);
+
+  spt.EnsureSourcePositions();
 }
 
 
 TEST_CASE(SourcePosition_TryCatchFinally) {
   const char* kScript =
       "var x = 5;\n"
       "var y = 5;\n"
       "main() {\n"
       "  try {\n"
       "    throw 'A';\n"
@@ skipping 30 matching lines @@
   spt.FuzzyInstructionMatchAt("StoreLocal(:finally_ret_val", 8, 5);    // 'r'
 
   spt.FuzzyInstructionMatchAt("Constant(#99", 10, 12);                 // '9'
   spt.FuzzyInstructionMatchAt("Return", 10, 5);                        // 'r'
 
   spt.FuzzyInstructionMatchAt("LoadLocal(:saved_try_context", 9, 13);  // '{'
   spt.FuzzyInstructionMatchAt("StoreLocal(:current_context", 9, 13);   // '{'
 
   spt.FuzzyInstructionMatchAt("Constant(#99", 10, 12);                 // '9'
   spt.FuzzyInstructionMatchAt("Return", 10, 5);                        // 'r'
+
+  spt.EnsureSourcePositions();
+}
+
+
+TEST_CASE(SourcePosition_InstanceFields) {
+  const char* kScript =
+      "class A {"

[rmacnak, 2016/01/14 00:28:08]

missing new line...

[Cutch, 2016/01/14 15:25:10]

Done.

+      "  var x;\n"
+      "  var y;\n"
+      "}\n"
+      "main() {\n"
+      "  var z = new A();\n"
+      "  z.x = 99;\n"
+      "  z.y = z.x;\n"
+      "  return z.y;\n"
+      "}\n";
+
+  SourcePositionTest spt(thread, kScript);
+  spt.BuildGraphFor("main");
+  spt.FuzzyInstructionMatchAt("AllocateObject(A)", 5, 15);       // 'A'

[rmacnak, 2016/01/14 00:28:08]

...Making these lines short by 1.

[Cutch, 2016/01/14 15:25:10]

Done.

+  spt.FuzzyInstructionMatchAt("StaticCall", 5, 15);              // 'A'
+  spt.FuzzyInstructionMatchAt("StoreLocal(z", 5, 9);             // '='
+  spt.InstanceCallAt(6, 5, "set:x");                             // 'x'
+  spt.InstanceCallAt(7, 11, "get:x");                            // 'x'
+  spt.InstanceCallAt(7, 5, "set:y");                             // 'y'
+
+  spt.InstanceCallAt(8, 12, "get:y");                            // 'y'
+  spt.FuzzyInstructionMatchAt("DebugStepCheck", 8, 3);
+  spt.FuzzyInstructionMatchAt("Return", 8, 3);
+
+  spt.EnsureSourcePositions();
+}
+
+
+TEST_CASE(SourcePosition_Await) {
+  const char* kScript =
+      "import 'dart:async';\n"
+      "var x = 5;\n"
+      "var y = 5;\n"
+      "foo(Future f1, Future f2) async {\n"
+      "  await f1;\n"
+      "  await f2;\n"
+      "  return 55;\n"
+      "}\n"
+      "main() {\n"
+      "  foo(new Future.value(33));\n"
+      "}\n";
+
+  SourcePositionTest spt(thread, kScript);
+  spt.BuildGraphFor("foo");

[rmacnak, 2016/01/14 00:28:08]

This doesn't actually test 'await'. All that transformed code is in 'foo.<async
body>'.

[Cutch, 2016/01/14 15:25:10]

Correct, I've renamed this to be SourcePosition_Async as the generated code is
all related to the async machinery. 

+  spt.EnsureSourcePositions();
 }
 
 }  // namespace dart