VM: Re-format to use at most one newline between functions

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/flow_graph_builder.h"
 #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"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 #define DUMP_ASSERT(condition)                                                 \
   if (!(condition)) {                                                          \
     dart::Expect(__FILE__, __LINE__).Fail("expected: %s", #condition);         \
@@ skipping 254 matching lines @@
   Thread* thread_;
   Isolate* isolate_;
   const char* script_;
   Library& root_lib_;
   Script& root_script_;
   const char* graph_name_;
   FlowGraph* graph_;
   GrowableArray<BlockEntryInstr*>* blocks_;
 };
 
-
 TEST_CASE(SourcePosition_InstanceCalls) {
   const char* kScript =
       "var x = 5;\n"
       "var y = 5;\n"
       "main() {\n"
       "  var z = x + y;\n"
       "  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";
@@ skipping 10 matching lines @@
   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"
       "      return y;\n"
       "    }\n"
       "    x++;\n"
@@ skipping 28 matching lines @@
   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"
       "      continue;\n"
       "    }\n"
       "    break;\n"
@@ skipping 19 matching lines @@
   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"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
@@ skipping 18 matching lines @@
 
   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"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
@@ skipping 23 matching lines @@
 
   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"
       "  z = x | y;\n"
       "  z = x ^ y;\n"
       "  z = ~z;\n"
@@ skipping 29 matching lines @@
   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"
       "    case 2: return 4;\n"
       "    default: return 5;\n"
       "  }\n"
       "}\n";
 
-
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
 
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
   spt.FuzzyInstructionMatchAt("Constant(#Field", 4, 11);
   spt.FuzzyInstructionMatchAt("LoadStaticField", 4, 11);
   spt.FuzzyInstructionMatchAt("StoreLocal(:switch_expr", 4, 11);
 
   spt.FuzzyInstructionMatchAt("Constant(#1", 5, 10);
@@ skipping 12 matching lines @@
   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"
       "  } catch (e) {\n"
       "    print(e);\n"
       "    return 77;\n"
@@ skipping 31 matching lines @@
 
   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();
 }
 
 #endif  // !PRODUCT
 
 static bool SyntheticRoundTripTest(TokenPosition token_pos) {
   const TokenPosition synthetic_token_pos = token_pos.ToSynthetic();
   return synthetic_token_pos.FromSynthetic() == token_pos;
 }
 
-
 VM_UNIT_TEST_CASE(SourcePosition_SyntheticTokens) {
   EXPECT(TokenPosition::kNoSourcePos == -1);
   EXPECT(TokenPosition::kMinSourcePos == 0);
   EXPECT(TokenPosition::kMaxSourcePos > 0);
   EXPECT(TokenPosition::kMaxSourcePos > TokenPosition::kMinSourcePos);
   EXPECT(TokenPosition::kMinSource.value() == TokenPosition::kMinSourcePos);
   EXPECT(TokenPosition::kMaxSource.value() == TokenPosition::kMaxSourcePos);
   EXPECT(!TokenPosition(0).IsSynthetic());
   EXPECT(TokenPosition(0).ToSynthetic().IsSynthetic());
   EXPECT(TokenPosition(9).ToSynthetic().IsSynthetic());
   EXPECT(!TokenPosition(-1).FromSynthetic().IsSynthetic());
   EXPECT(!TokenPosition::kNoSource.IsSynthetic());
   EXPECT(!TokenPosition::kLast.IsSynthetic());
   EXPECT(SyntheticRoundTripTest(TokenPosition(0)));
   EXPECT(SyntheticRoundTripTest(TokenPosition::kMaxSource));
   EXPECT(SyntheticRoundTripTest(TokenPosition::kMinSource));
 }
 
 }  // namespace dart