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

runtime/vm/parser_test.cc

 // Copyright (c) 2011, 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/parser.h"
 #include "vm/ast_printer.h"
 #include "vm/class_finalizer.h"
 #include "vm/debugger.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
-#include "vm/parser.h"
 #include "vm/symbols.h"
 #include "vm/thread.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, show_invisible_frames);
 
-
 static void DumpFunction(const Library& lib,
                          const char* cname,
                          const char* fname) {
   const String& classname =
       String::Handle(Symbols::New(Thread::Current(), cname));
   String& funcname = String::Handle(String::New(fname));
 
   bool retval;
   EXPECT(Isolate::Current() != NULL);
   LongJumpScope jump;
@@ skipping 14 matching lines @@
     } else {
       OS::Print("AST printer not supported.");
     }
     retval = true;
   } else {
     retval = false;
   }
   EXPECT(retval);
 }
 
-
 void CheckField(const Library& lib,
                 const char* class_name,
                 const char* field_name,
                 bool expect_static,
                 bool is_final) {
   const String& classname =
       String::Handle(Symbols::New(Thread::Current(), class_name));
   Class& cls = Class::Handle(lib.LookupClass(classname));
   EXPECT(!cls.IsNull());
 
@@ skipping 16 matching lines @@
     EXPECT(!function.IsNull());
     functionname ^= Field::SetterName(fieldname);
     function ^= cls.LookupDynamicFunction(functionname);
     EXPECT(is_final ? function.IsNull() : !function.IsNull());
   }
   EXPECT(!field.IsNull());
 
   EXPECT_EQ(field.is_static(), expect_static);
 }
 
-
 void CheckFunction(const Library& lib,
                    const char* class_name,
                    const char* function_name,
                    bool expect_static) {
   const String& classname =
       String::Handle(Symbols::New(Thread::Current(), class_name));
   Class& cls = Class::Handle(lib.LookupClass(classname));
   EXPECT(!cls.IsNull());
 
   String& functionname = String::Handle(String::New(function_name));
   Function& function = Function::Handle();
   if (expect_static) {
     function ^= cls.LookupStaticFunction(functionname);
   } else {
     function ^= cls.LookupDynamicFunction(functionname);
   }
   EXPECT(!function.IsNull());
 }
 
-
 TEST_CASE(ParseClassDefinition) {
   const char* script_chars =
       "class C { }  \n"
       "class A {    \n"
       "  var f0;              \n"
       "  int f1;              \n"
       "  final f2;            \n"
       "  final int f3, f4;    \n"
       "  static String s1, s2;   \n"
       "  static const int s3 = 8675309;    \n"
@@ skipping 15 matching lines @@
   CheckField(lib, "A", "f2", false, true);
   CheckField(lib, "A", "f3", false, true);
   CheckField(lib, "A", "f4", false, true);
   CheckField(lib, "A", "s1", true, false);
   CheckField(lib, "A", "s2", true, false);
   CheckField(lib, "A", "s3", true, true);
   CheckFunction(lib, "A", "bar", true);
   CheckFunction(lib, "A", "foo", true);
 }
 
-
 TEST_CASE(Parser_TopLevel) {
   const char* script_chars =
       "class A extends B {    \n"
       "  static bar(var i, [var d = 5]) { return 77; } \n"
       "  static foo() { return 42; } \n"
       "  static baz(var i) { var q = 5; return i + q; } \n"
       "}   \n"
       "    \n"
       "class B {  \n"
       "  static bam(k) { return A.foo(); }   \n"
       "}   \n";
 
   String& url = String::Handle(String::New("dart-test:Parser_TopLevel"));
   String& source = String::Handle(String::New(script_chars));
   Script& script =
       Script::Handle(Script::New(url, source, RawScript::kScriptTag));
   Library& lib = Library::ZoneHandle(Library::CoreLibrary());
 
   script.Tokenize(String::Handle(String::New("")));
 
   Parser::ParseCompilationUnit(lib, script);
   EXPECT(ClassFinalizer::ProcessPendingClasses());
 
   DumpFunction(lib, "A", "foo");
   DumpFunction(lib, "A", "bar");
   DumpFunction(lib, "A", "baz");
   DumpFunction(lib, "B", "bam");
 }
 
-
 #ifndef PRODUCT
 
-
 static char* saved_vars = NULL;
 
-
 static char* SkipIndex(const char* input) {
   char* output_buffer = new char[strlen(input)];
   char* output = output_buffer;
 
   while (input[0] != '\0') {
     const char* index_pos = strstr(input, "index=");
     if (index_pos == NULL) {
       while (input[0] != '\0') {
         *output++ = *input++;
       }
       break;
     }
 
     // Copy prefix until "index="
     while (input < index_pos) {
       *output++ = *input++;
     }
 
     // Skip until space.
     input += strcspn(input, " ");
     // Skip until next non-space.
     input += strspn(input, " ");
   }
 
   output[0] = '\0';
   return output_buffer;
 }
 
-
 // Saves the var descriptors for all frames on the stack as a string.
 static void SaveVars(Dart_IsolateId isolate_id,
                      intptr_t bp_id,
                      const Dart_CodeLocation& loc) {
   DebuggerStackTrace* stack = Isolate::Current()->debugger()->StackTrace();
   intptr_t num_frames = stack->Length();
   const int kBufferLen = 2048;
   char* buffer = reinterpret_cast<char*>(malloc(kBufferLen));
   char* pos = buffer;
   LocalVarDescriptors& var_desc = LocalVarDescriptors::Handle();
   for (intptr_t i = 0; i < num_frames; i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     var_desc = frame->code().GetLocalVarDescriptors();
     const char* var_str = SkipIndex(var_desc.ToCString());
     const char* function_str =
         String::Handle(frame->function().QualifiedUserVisibleName())
             .ToCString();
     pos += OS::SNPrint(pos, (kBufferLen - (pos - buffer)), "%s\n%s",
                        function_str, var_str);
     delete[] var_str;
   }
   pos[0] = '\0';
   if (saved_vars != NULL) {
     free(saved_vars);
   }
   saved_vars = buffer;
 }
 
-
 // Uses the debugger to pause the program and capture the variable
 // descriptors for all frames on the stack.
 static char* CaptureVarsAtLine(Dart_Handle lib, const char* entry, int line) {
   EXPECT(ClassFinalizer::ProcessPendingClasses());
   bool saved_flag = FLAG_show_invisible_frames;
   FLAG_show_invisible_frames = true;
   Dart_SetPausedEventHandler(SaveVars);
   EXPECT_VALID(Dart_SetBreakpoint(NewString(TestCase::url()), line));
   saved_vars = NULL;
   EXPECT_VALID(Dart_Invoke(lib, NewString(entry), 0, NULL));
   char* tmp = saved_vars;
   saved_vars = NULL;
   FLAG_show_invisible_frames = saved_flag;
   return tmp;
 }
 
-
 TEST_CASE(Parser_AllocateVariables_CapturedVar) {
   const char* kScriptChars =
       "int main() {\n"
       "  var value = 11;\n"
       "  int f(var param) {\n"
       "    return param + value;\n"  // line 4
       "  }\n"
       "  return f(22);\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 17 matching lines @@
       "main\n"
       " 0 ContextLevel  level=0   begin=0   end=6\n"
       " 1 ContextLevel  level=1   begin=8   end=16\n"
       " 2 CurrentCtx    scope=0   begin=0   end=0   name=:current_context_var\n"
       " 3 ContextVar    level=1   begin=10  end=37  name=value\n"
       " 4 StackVar      scope=2   begin=12  end=37  name=f\n",
       vars);
   free(vars);
 }
 
-
 TEST_CASE(Parser_AllocateVariables_NestedCapturedVar) {
   const char* kScriptChars =
       "int a() {\n"
       "  int b() {\n"
       "    var value = 11;\n"
       "    int c() {\n"
       "      return value;\n"  // line 5
       "    }\n"
       "    return c();\n"
       "  }\n"
@@ skipping 35 matching lines @@
       // don't save the entry context if the function has no captured
       // variables.
       "a\n"
       " 0 ContextLevel  level=0   begin=0   end=14\n"
       " 1 CurrentCtx    scope=0   begin=0   end=0   name=:current_context_var\n"
       " 2 StackVar      scope=2   begin=6   end=46  name=b\n",
       vars);
   free(vars);
 }
 
-
 TEST_CASE(Parser_AllocateVariables_TwoChains) {
   const char* kScriptChars =
       "int a() {\n"
       "  var value1 = 11;\n"
       "  int b() {\n"
       "    int aa() {\n"
       "      var value2 = 12;\n"
       "      int bb() {\n"
       "        return value2;\n"  // line 7
       "      }\n"
@@ skipping 59 matching lines @@
       " 0 ContextLevel  level=0   begin=0   end=6\n"
       " 1 ContextLevel  level=1   begin=8   end=16\n"
       " 2 CurrentCtx    scope=0   begin=0   end=0"
       "   name=:current_context_var\n"
       " 3 ContextVar    level=1   begin=10  end=71  name=value1\n"
       " 4 StackVar      scope=2   begin=12  end=71  name=b\n",
       vars);
   free(vars);
 }
 
-
 TEST_CASE(Parser_AllocateVariables_Issue7681) {
   // This is a distilled version of the program from Issue 7681.
   //
   // When we create the closure at line 11, we need to make sure to
   // save the entry context instead of chaining to the parent context.
   //
   // This test is somewhat redundant with CapturedVarChain but
   // included for good measure.
   const char* kScriptChars =
       "class X {\n"
@@ skipping 37 matching lines @@
 
       // No context is saved here since no vars are captured.
       "doIt\n"
       " 0 ContextLevel  level=0   begin=0   end=18\n"
       " 1 CurrentCtx    scope=0   begin=0   end=0   name=:current_context_var\n"
       " 2 StackVar      scope=2   begin=35  end=80  name=x\n",
       vars);
   free(vars);
 }
 
-
 TEST_CASE(Parser_AllocateVariables_CaptureLoopVar) {
   // This test verifies that...
   //
   //   https://code.google.com/p/dart/issues/detail?id=18561
   //
   // ...stays fixed.
   const char* kScriptChars =
       "int outer() {\n"
       "  for(int i = 0; i < 1; i++) {\n"
       "    var value = 11 + i;\n"
@@ skipping 86 matching lines @@
       " 2 CurrentCtx    scope=0   begin=0   end=0   name=:current_context_var\n"
       " 3 ContextVar    level=1   begin=9   end=81  name=x\n"
       " 4 StackVar      scope=2   begin=11  end=81  name=b\n",
       vars);
   free(vars);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart