Report missing semicolons after function declarations

runtime/vm/report.cc

 // Copyright (c) 2014, 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/report.h"
 
 #include "vm/code_patcher.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, stacktrace_depth_on_warning, 5,
             "Maximal number of stack frames to print after a runtime warning.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 DEFINE_FLAG(bool, warn_on_javascript_compatibility, false,
             "Warn on incompatibilities between vm and dart2js.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 
 DECLARE_FLAG(bool, always_megamorphic_calls);
 
 RawString* Report::PrependSnippet(Kind kind,
                                   const Script& script,
                                   intptr_t token_pos,
+                                  bool report_after_token,
                                   const String& message) {
   const char* message_header;
   switch (kind) {
     case kWarning: message_header = "warning"; break;
     case kJSWarning: message_header = "javascript compatibility warning"; break;
     case kError: message_header = "error"; break;
     case kMalformedType: message_header = "malformed type"; break;
     case kMalboundedType: message_header = "malbounded type"; break;
     case kBailout: message_header = "bailout"; break;
     default: message_header = ""; UNREACHABLE();
   }
   String& result = String::Handle();
   if (!script.IsNull()) {
     const String& script_url = String::Handle(script.url());
     if (token_pos >= 0) {
-      intptr_t line, column;
-      script.GetTokenLocation(token_pos, &line, &column);
+      intptr_t line, column, token_len;
+      script.GetTokenLocation(token_pos, &line, &column, &token_len);
+      if (report_after_token) {
+        column += token_len;
+      }
       // Only report the line position if we have the original source. We still
       // need to get a valid column so that we can report the ^ mark below the
       // snippet.
       // Allocate formatted strings in old sapce as they may be created during
       // optimizing compilation. Those strings are created rarely and should not
       // polute old space.
       if (script.HasSource()) {
         result = String::NewFormatted(Heap::kOld,
                                       "'%s': %s: line %" Pd " pos %" Pd ": ",
                                       script_url.ToCString(),
@@ skipping 57 matching lines @@
   LongJumpV(prev_error, script, token_pos, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
 
 void Report::LongJumpV(const Error& prev_error,
                        const Script& script, intptr_t token_pos,
                        const char* format, va_list args) {
   const Error& error = Error::Handle(LanguageError::NewFormattedV(
-      prev_error, script, token_pos,
+      prev_error, script, token_pos, Report::AtLocation,
       kError, Heap::kNew,
       format, args));
   LongJump(error);
   UNREACHABLE();
 }
 
 
 void Report::MessageF(Kind kind, const Script& script, intptr_t token_pos,
-                      const char* format, ...) {
+                      bool report_after_token, const char* format, ...) {
   va_list args;
   va_start(args, format);
-  MessageV(kind, script, token_pos, format, args);
+  MessageV(kind, script, token_pos, report_after_token, format, args);
   va_end(args);
 }
 
 
-void Report::MessageV(Kind kind, const Script& script, intptr_t token_pos,
+void Report::MessageV(Kind kind,
+                      const Script& script,
+                      intptr_t token_pos,
+                      bool report_after_token,
                       const char* format, va_list args) {
   if (kind < kError) {
     // Reporting a warning.
     if (FLAG_silent_warnings) {
       return;
     }
     if (!FLAG_warning_as_error) {
       const String& msg = String::Handle(String::NewFormattedV(format, args));
       const String& snippet_msg = String::Handle(
-          PrependSnippet(kind, script, token_pos, msg));
+          PrependSnippet(kind, script, token_pos, report_after_token, msg));
       OS::Print("%s", snippet_msg.ToCString());
       if (kind == kJSWarning) {
         TraceJSWarning(script, token_pos, msg);
         // Do not print stacktrace if we have not executed Dart code yet.
         if (Thread::Current()->top_exit_frame_info() != 0) {
           const Stacktrace& stacktrace =
               Stacktrace::Handle(Exceptions::CurrentStacktrace());
           intptr_t idx = 0;
           OS::Print("%s", stacktrace.ToCStringInternal(
               &idx, FLAG_stacktrace_depth_on_warning));
         }
       }
       return;
     }
   }
   // Reporting an error (or a warning as error).
   const Error& error = Error::Handle(
       LanguageError::NewFormattedV(Error::Handle(),  // No previous error.
-                                   script, token_pos,
+                                   script, token_pos, report_after_token,
                                    kind, Heap::kNew,
                                    format, args));
   if (kind == kJSWarning) {
     Exceptions::ThrowJavascriptCompatibilityError(error.ToErrorCString());
     UNREACHABLE();
   }
   LongJump(error);
   UNREACHABLE();
 }
 
@@ skipping 45 matching lines @@
   ASSERT(FLAG_warn_on_javascript_compatibility);
   if (FLAG_silent_warnings) return;
   Zone* zone = Thread::Current()->zone();
   const Code& caller_code = Code::Handle(zone,
                                          caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   const uword caller_pc = caller_frame->pc();
   const intptr_t token_pos = caller_code.GetTokenIndexOfPC(caller_pc);
   const Function& caller = Function::Handle(zone, caller_code.function());
   const Script& script = Script::Handle(zone, caller.script());
-  MessageF(kJSWarning, script, token_pos, "%s", msg);
+  MessageF(kJSWarning, script, token_pos, Report::AtLocation, "%s", msg);
 }
 
 
 void Report::TraceJSWarning(const Script& script,
                             intptr_t token_pos,
                             const String& message) {
   const int64_t micros = OS::GetCurrentTimeMicros();
   Isolate* isolate = Isolate::Current();
   TraceBuffer* trace_buffer = isolate->trace_buffer();
   if (trace_buffer == NULL) {
     TraceBuffer::Init(isolate);
     trace_buffer = isolate->trace_buffer();
   }
   JSONStream js;
   {
     JSONObject trace_warning(&js);
     trace_warning.AddProperty("type", "JSCompatibilityWarning");
     trace_warning.AddProperty("script", script);
     trace_warning.AddProperty("tokenPos", token_pos);
     trace_warning.AddProperty("message", message);
   }
   trace_buffer->Trace(micros, js.ToCString(), true);  // Already escaped.
 }
 
 }  // namespace dart