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(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);
+      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 Token::kNoSourcePos.
+  void EnsureSourcePositions() {
+    for (intptr_t i = 0; i < blocks_->length(); i++) {
+      BlockEntryInstr* entry = (*blocks_)[i];
+      DUMP_ASSERT(entry->token_pos() != Token::kNoSourcePos);
+      for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
+        Instruction* instr = it.Current();
+        DUMP_ASSERT(instr->token_pos() != Token::kNoSourcePos);
+      }
+    }
+  }
+
  private:
   void DumpInstruction(Instruction* instr) {
-    const intptr_t token_pos = instr->token_pos();
+    intptr_t token_pos = instr->token_pos();
+    bool synthetic = false;
+    if (Token::IsSynthetic(token_pos)) {
+      synthetic = true;
+      token_pos = Token::FromSynthetic(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;
     intptr_t token_column = -1;
     root_script_.GetTokenLocation(token_pos,
                                   &token_line,
                                   &token_column,
                                   NULL);
-    THR_Print("       %02d:%02d -- %s\n",
-              static_cast<int>(token_line),
-              static_cast<int>(token_column),
-              instr->ToCString());
+    if (synthetic) {
+      THR_Print("      *%02d:%02d -- %s\n",
+                static_cast<int>(token_line),
+                static_cast<int>(token_column),
+                instr->ToCString());
+    } else {
+      THR_Print("       %02d:%02d -- %s\n",
+                static_cast<int>(token_line),
+                static_cast<int>(token_column),
+                instr->ToCString());
+    }
   }
 
   Instruction* FindFirstInstructionAt(intptr_t line, intptr_t column) {
     ZoneGrowableArray<Instruction*>* instructions =
         FindInstructionsAt(line, column);
     if (instructions->length() == 0) {
       return NULL;
     }
     return instructions->At(0);
   }
 
   ZoneGrowableArray<Instruction*>* FindInstructionsAt(
       intptr_t line, intptr_t column) {
     ZoneGrowableArray<Instruction*>* instructions =
         new ZoneGrowableArray<Instruction*>();
     for (intptr_t i = 0; i < blocks_->length(); i++) {
       BlockEntryInstr* entry = (*blocks_)[i];
       for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
         Instruction* instr = it.Current();
         intptr_t token_pos = instr->token_pos();
+        if (Token::IsSynthetic(token_pos)) {
+          token_pos = Token::FromSynthetic(token_pos);
+        }
         if (token_pos < 0) {
           continue;
         }
         intptr_t token_line = -1;
         intptr_t token_column = -1;
         root_script_.GetTokenLocation(token_pos,
                                       &token_line,
                                       &token_column,
                                       NULL);
         if (token_line == line) {
@@ skipping 62 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 {\n"
+      "  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)", 6, 15);       // 'A'
+  spt.FuzzyInstructionMatchAt("StaticCall", 6, 15);              // 'A'
+  spt.FuzzyInstructionMatchAt("StoreLocal(z", 6, 9);             // '='
+  spt.InstanceCallAt("set:x", 7, 5);                             // 'x'
+  spt.InstanceCallAt("get:x", 8, 11);                            // 'x'
+  spt.InstanceCallAt("set:y", 8, 5);                             // 'y'
+
+  spt.InstanceCallAt("get:y", 9, 12);                            // 'y'
+  spt.FuzzyInstructionMatchAt("DebugStepCheck", 9, 3);
+  spt.FuzzyInstructionMatchAt("Return", 9, 3);
+
+  spt.EnsureSourcePositions();
+}
+
+
+TEST_CASE(SourcePosition_Async) {
+  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");
+  spt.EnsureSourcePositions();
+  spt.Dump();
+}
+
+
+static bool SyntheticRoundTripTest(intptr_t token_pos) {
+  return Token::FromSynthetic(Token::ToSynthetic(token_pos)) == token_pos;
+}
+
+
+UNIT_TEST_CASE(SourcePosition_SyntheticTokens) {
+  EXPECT(Token::kNoSourcePos == -1);
+  EXPECT(Token::kMinSourcePos == 0);
+  EXPECT(Token::kMaxSourcePos > 0);
+
+  EXPECT(!Token::IsSynthetic(0));
+  EXPECT(Token::IsSynthetic(Token::ToSynthetic(0)));
+  EXPECT(Token::IsSynthetic(Token::ToSynthetic(9)));
+  EXPECT(!Token::IsSynthetic(Token::FromSynthetic(-1)));
+  EXPECT(!Token::IsSynthetic(ClassifyingTokenPositions::kPrivate));
+  EXPECT(!Token::IsSynthetic(ClassifyingTokenPositions::kLast));
+
+  EXPECT(SyntheticRoundTripTest(0));
+  EXPECT(SyntheticRoundTripTest(Token::kMaxSourcePos));
+  EXPECT(SyntheticRoundTripTest(Token::kMinSourcePos));
 }
 
 }  // namespace dart