clang-format runtime/vm

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"
 
 namespace dart {
 
 #ifndef PRODUCT
 
 #define DUMP_ASSERT(condition)                                                 \
   if (!(condition)) {                                                          \
     dart::Expect(__FILE__, __LINE__).Fail("expected: %s", #condition);         \
     THR_Print(">>> BEGIN source position table for `%s`\n", graph_name_);      \
     Dump();                                                                    \
     THR_Print("<<< END source position table for `%s`\n", graph_name_);        \
     OS::Abort();                                                               \
   }
 
 class SourcePositionTest : public ValueObject {
  public:
-  SourcePositionTest(Thread* thread,
-                     const char* script)
+  SourcePositionTest(Thread* thread, const char* script)
       : thread_(thread),
         isolate_(thread->isolate()),
         script_(script),
         root_lib_(Library::Handle()),
         root_script_(Script::Handle()),
         graph_(NULL),
         blocks_(NULL) {
     EXPECT(thread_ != NULL);
     EXPECT(isolate_ != NULL);
     EXPECT(script_ != NULL);
     Dart_Handle lib = TestCase::LoadTestScript(script, NULL);
     EXPECT_VALID(lib);
     root_lib_ ^= Api::UnwrapHandle(lib);
     EXPECT(!root_lib_.IsNull());
-    root_script_ ^= root_lib_.LookupScript(
-        String::Handle(String::New(USER_TEST_URI)));
+    root_script_ ^=
+        root_lib_.LookupScript(String::Handle(String::New(USER_TEST_URI)));
     EXPECT(!root_script_.IsNull());
   }
 
   void BuildGraphFor(const char* function_name) {
     graph_ = NULL;
     blocks_ = NULL;
     graph_name_ = NULL;
 
     // Only support unoptimized code for now.
     const bool optimized = false;
 
     const Function& function =
         Function::Handle(GetFunction(root_lib_, function_name));
     ZoneGrowableArray<const ICData*>* ic_data_array =
         new ZoneGrowableArray<const ICData*>();
-    ParsedFunction* parsed_function = new ParsedFunction(
-        thread_, Function::ZoneHandle(function.raw()));
+    ParsedFunction* parsed_function =
+        new ParsedFunction(thread_, Function::ZoneHandle(function.raw()));
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
-    FlowGraphBuilder builder(
-        *parsed_function,
-        *ic_data_array,
-        NULL,
-        Compiler::kNoOSRDeoptId);
+    FlowGraphBuilder builder(*parsed_function, *ic_data_array, NULL,
+                             Compiler::kNoOSRDeoptId);
     graph_ = builder.BuildGraph();
     EXPECT(graph_ != NULL);
     blocks_ = graph_->CodegenBlockOrder(optimized);
     EXPECT(blocks_ != NULL);
     graph_name_ = function_name;
     EXPECT(graph_name_ != NULL);
   }
 
   // Expect to find an instance call at |line| and |column|.
   void InstanceCallAt(intptr_t line,
@@ skipping 12 matching lines @@
           }
         } 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) {
+  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) {
+  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);
       EXPECT(instr != NULL);
       if (instr->IsStaticCall()) {
         const char* haystack = instr->ToCString();
         if (strstr(haystack, needle) != NULL) {
           count++;
@@ skipping 54 matching lines @@
       synthetic = true;
       token_pos = token_pos.FromSynthetic();
     }
     if (token_pos.IsClassifying()) {
       const char* token_pos_string = token_pos.ToCString();
       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);
+    root_script_.GetTokenLocation(token_pos, &token_line, &token_column, NULL);
     if (synthetic) {
-      THR_Print("      *%02d:%02d -- %s\n",
-                static_cast<int>(token_line),
-                static_cast<int>(token_column),
-                instr->ToCString());
+      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());
+      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*>* 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();
         TokenPosition token_pos = instr->token_pos();
         if (token_pos.IsSynthetic()) {
           token_pos = token_pos.FromSynthetic();
         }
         if (!token_pos.IsReal()) {
           continue;
         }
         intptr_t token_line = -1;
         intptr_t token_column = -1;
-        root_script_.GetTokenLocation(token_pos,
-                                      &token_line,
-                                      &token_column,
+        root_script_.GetTokenLocation(token_pos, &token_line, &token_column,
                                       NULL);
         if (token_line == line) {
           if ((column < 0) || (column == token_column)) {
             instructions->Add(instr);
           }
         }
       }
     }
     return instructions;
   }
 
   ZoneGrowableArray<Instruction*>* FindInstructionsAt(intptr_t token_pos) {
     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();
         if (instr->token_pos().value() == token_pos) {
           instructions->Add(instr);
         }
       }
     }
     return instructions;
   }
 
   RawFunction* GetFunction(const Library& lib, const char* name) {
-    const Function& result = Function::Handle(lib.LookupFunctionAllowPrivate(
-        String::Handle(String::New(name))));
+    const Function& result = Function::Handle(
+        lib.LookupFunctionAllowPrivate(String::Handle(String::New(name))));
     EXPECT(!result.IsNull());
     return result.raw();
   }
 
   RawFunction* GetFunction(const Class& cls, const char* name) {
-    const Function& result = Function::Handle(cls.LookupFunctionAllowPrivate(
-        String::Handle(String::New(name))));
+    const Function& result = Function::Handle(
+        cls.LookupFunctionAllowPrivate(String::Handle(String::New(name))));
     EXPECT(!result.IsNull());
     return result.raw();
   }
 
   RawClass* GetClass(const Library& lib, const char* name) {
     const Class& cls = Class::Handle(
         lib.LookupClass(String::Handle(Symbols::New(thread_, name))));
     EXPECT(!cls.IsNull());  // No ambiguity error expected.
     return cls.raw();
   }
@@ skipping 358 matching lines @@
   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);
-  spt.FuzzyInstructionMatchAt("LoadLocal(:switch_expr", 5, 5);   // 'c'
-  spt.InstanceCallAt(5, 10, Token::kEQ);                         // '1'
+  spt.FuzzyInstructionMatchAt("LoadLocal(:switch_expr", 5, 5);  // 'c'
+  spt.InstanceCallAt(5, 10, Token::kEQ);                        // '1'
 
-  spt.FuzzyInstructionMatchAt("Constant(#3", 5, 20);             // '3'
+  spt.FuzzyInstructionMatchAt("Constant(#3", 5, 20);  // '3'
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 5, 13);
   spt.FuzzyInstructionMatchAt("Return", 5, 13);
 
   spt.FuzzyInstructionMatchAt("Constant(#2", 6, 10);
-  spt.FuzzyInstructionMatchAt("LoadLocal(:switch_expr", 6, 5);   // 'c'
-  spt.InstanceCallAt(6, 10, Token::kEQ);                         // '2'
+  spt.FuzzyInstructionMatchAt("LoadLocal(:switch_expr", 6, 5);  // 'c'
+  spt.InstanceCallAt(6, 10, Token::kEQ);                        // '2'
 
-  spt.FuzzyInstructionMatchAt("Constant(#4", 6, 20);             // '4'
+  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("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"
       "  } finally {\n"
       "    return 99;\n"
       "  }\n"
       "}\n";
 
   SourcePositionTest spt(thread, kScript);
   spt.BuildGraphFor("main");
 
   spt.FuzzyInstructionMatchAt("DebugStepCheck", 3, 5);
   spt.FuzzyInstructionMatchAt("CheckStackOverflow", 3, 5);
 
-  spt.FuzzyInstructionMatchAt("LoadLocal(:current_context", 4, 3);     // 't'
+  spt.FuzzyInstructionMatchAt("LoadLocal(:current_context", 4, 3);  // 't'
   spt.FuzzyInstructionMatchAt("StoreLocal(:saved_try_context", 4, 3);
 
-  spt.FuzzyInstructionMatchAt("Constant(#A", 5, 11);                   // 'A'
-  spt.FuzzyInstructionMatchAt("Throw", 5, 5);                          // 't'
+  spt.FuzzyInstructionMatchAt("Constant(#A", 5, 11);  // 'A'
+  spt.FuzzyInstructionMatchAt("Throw", 5, 5);         // 't'
 
-  spt.FuzzyInstructionMatchAt("LoadLocal(:saved_try_context", 6, 5);   // 'c'
-  spt.FuzzyInstructionMatchAt("StoreLocal(:current_context", 6, 5);    // 'c'
-  spt.FuzzyInstructionMatchAt("LoadLocal(:exception_var", 6, 5);       // 'c'
-  spt.FuzzyInstructionMatchAt("StoreLocal(e", 6, 5);                   // 'c'
+  spt.FuzzyInstructionMatchAt("LoadLocal(:saved_try_context", 6, 5);  // 'c'
+  spt.FuzzyInstructionMatchAt("StoreLocal(:current_context", 6, 5);   // 'c'
+  spt.FuzzyInstructionMatchAt("LoadLocal(:exception_var", 6, 5);      // 'c'
+  spt.FuzzyInstructionMatchAt("StoreLocal(e", 6, 5);                  // 'c'
 
-  spt.FuzzyInstructionMatchAt("LoadLocal(e", 7, 11);                   // 'e'
+  spt.FuzzyInstructionMatchAt("LoadLocal(e", 7, 11);  // 'e'
 
-  spt.FuzzyInstructionMatchAt("StaticCall", 7, 5);                     // 'p'
+  spt.FuzzyInstructionMatchAt("StaticCall", 7, 5);  // 'p'
 
-  spt.FuzzyInstructionMatchAt("Constant(#77", 8, 12);                  // '7'
-  spt.FuzzyInstructionMatchAt("StoreLocal(:finally_ret_val", 8, 5);    // 'r'
+  spt.FuzzyInstructionMatchAt("Constant(#77", 8, 12);                // '7'
+  spt.FuzzyInstructionMatchAt("StoreLocal(:finally_ret_val", 8, 5);  // 'r'
 
-  spt.FuzzyInstructionMatchAt("Constant(#99", 10, 12);                 // '9'
-  spt.FuzzyInstructionMatchAt("Return", 10, 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.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.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.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"
@@ skipping 34 matching lines @@
   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
-