Add support for javascript incompatibility warnings.

runtime/vm/exceptions.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/exceptions.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
@@ skipping 16 matching lines @@
 void __asan_unpoison_memory_region(void* ignore1, size_t ignore2) {}
 #endif  // defined(__has_feature)
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_stacktrace_at_throw, false,
             "Prints a stack trace everytime a throw occurs.");
 DEFINE_FLAG(bool, verbose_stacktrace, false,
     "Stack traces will include methods marked invisible.");
+DEFINE_FLAG(int, stacktrace_depth_on_warning, 5,
+            "Maximal number of stack frames to print after a runtime warning.");
+DECLARE_FLAG(bool, silent_warnings);
+DECLARE_FLAG(bool, warning_as_error);
+DECLARE_FLAG(bool, warn_on_javascript_compatibility);
+
 
 const char* Exceptions::kCastErrorDstName = "type cast";
 
 
 class StacktraceBuilder : public ValueObject {
  public:
   StacktraceBuilder() { }
   virtual ~StacktraceBuilder() { }
 
   virtual void AddFrame(const Code& code,
@@ skipping 287 matching lines @@
   // If instance class extends 'class Error' return '_stackTrace' field.
   Class& test_class = Class::Handle(isolate, instance.clazz());
   AbstractType& type = AbstractType::Handle(isolate, AbstractType::null());
   while (true) {
     if (test_class.raw() == error_class.raw()) {
       return error_class.LookupInstanceField(Symbols::_stackTrace());
     }
     type = test_class.super_type();
     if (type.IsNull()) return Field::null();
     test_class = type.type_class();
-  };
+  }
   UNREACHABLE();
   return Field::null();
 }
 
 
 RawStacktrace* Exceptions::CurrentStacktrace() {
   Isolate* isolate = Isolate::Current();
   RegularStacktraceBuilder frame_builder(true);
   BuildStackTrace(&frame_builder);
 
@@ skipping 327 matching lines @@
       class_name = &Symbols::IsolateSpawnException();
       break;
     case kIsolateUnhandledException:
       library = Library::IsolateLibrary();
       class_name = &Symbols::IsolateUnhandledException();
       break;
     case kJavascriptIntegerOverflowError:
       library = Library::CoreLibrary();
       class_name = &Symbols::JavascriptIntegerOverflowError();
       break;
+    case kJavascriptCompatibilityError:
+      library = Library::CoreLibrary();
+      class_name = &Symbols::JavascriptCompatibilityError();
+      break;
     case kAssertion:
       library = Library::CoreLibrary();
       class_name = &Symbols::AssertionError();
       constructor_name = &Symbols::DotCreate();
       break;
     case kCast:
       library = Library::CoreLibrary();
       class_name = &Symbols::CastError();
       constructor_name = &Symbols::DotCreate();
       break;
@@ skipping 17 matching lines @@
       class_name = &Symbols::MirroredCompilationError();
       break;
   }
 
   return DartLibraryCalls::InstanceCreate(library,
                                           *class_name,
                                           *constructor_name,
                                           arguments);
 }
 
+
+// Throw JavascriptCompatibilityError exception.
+static void ThrowJavascriptCompatibilityError(const char* msg) {
+  const Array& exc_args = Array::Handle(Array::New(1));
+  const String& msg_str = String::Handle(String::New(msg));
+  exc_args.SetAt(0, msg_str);
+  Exceptions::ThrowByType(Exceptions::kJavascriptCompatibilityError, exc_args);
+}
+
+
+void Exceptions::JSWarning(StackFrame* caller_frame, const char* format, ...) {
+  ASSERT(caller_frame != NULL);
+  ASSERT(FLAG_warn_on_javascript_compatibility);
+  if (FLAG_silent_warnings) return;
+  const Code& caller_code = Code::Handle(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(caller_code.function());
+  const Script& script = Script::Handle(caller.script());
+  va_list args;
+  va_start(args, format);
+  const Error& error = Error::Handle(
+      LanguageError::NewFormattedV(Error::Handle(),  // No previous error.
+                                   script, token_pos, LanguageError::kWarning,
+                                   Heap::kNew, format, args));
+  va_end(args);
+  if (FLAG_warning_as_error) {
+    ThrowJavascriptCompatibilityError(error.ToErrorCString());
+  } else {
+    OS::Print("javascript compatibility warning: %s", error.ToErrorCString());
+  }
+  const Stacktrace& stacktrace =
+     Stacktrace::Handle(Exceptions::CurrentStacktrace());
+  intptr_t idx = 0;
+  OS::Print("%s",
+            stacktrace.ToCStringInternal(&idx,
+                                         FLAG_stacktrace_depth_on_warning));
+}
+
 }  // namespace dart