Remove support for Javascript warnings in the VM.

runtime/lib/object.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/bootstrap_natives.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/code_patcher.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/report.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_type_checks);
-DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 // Helper function in stacktrace.cc.
 void _printCurrentStacktrace();
 
 DEFINE_NATIVE_ENTRY(DartCore_fatal, 1) {
   // The core library code entered an unrecoverable state.
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   const char* msg = instance.ToCString();
   OS::PrintErr("Fatal error in dart:core\n");
   _printCurrentStacktrace();
@@ skipping 83 matching lines @@
 
 
 DEFINE_NATIVE_ENTRY(Object_runtimeType, 1) {
   const Instance& instance = Instance::CheckedHandle(arguments->NativeArgAt(0));
   // Special handling for following types outside this native.
   ASSERT(!instance.IsString() && !instance.IsInteger() && !instance.IsDouble());
   return instance.GetType();
 }
 
 
-static void WarnOnJSIntegralNumTypeTest(
-    const Instance& instance,
-    const TypeArguments& instantiator_type_arguments,
-    const AbstractType& type) {
-  const bool instance_is_int = instance.IsInteger();
-  const bool instance_is_double = instance.IsDouble();
-  if (!(instance_is_int || instance_is_double)) {
-    return;
-  }
-  AbstractType& instantiated_type = AbstractType::Handle(type.raw());
-  if (!type.IsInstantiated()) {
-    instantiated_type = type.InstantiateFrom(instantiator_type_arguments, NULL);
-  }
-  if (instance_is_double) {
-    if (instantiated_type.IsIntType()) {
-      const double value = Double::Cast(instance).value();
-      if (floor(value) == value) {
-        Report::JSWarningFromNative(
-            false,  // Object_instanceOf and Object_as are not static calls.
-            "integral value of type 'double' is also considered to be "
-            "of type 'int'");
-      }
-    }
-  } else {
-    ASSERT(instance_is_int);
-    if (instantiated_type.IsDoubleType()) {
-      Report::JSWarningFromNative(
-          false,  // Object_instanceOf and Object_as are not static calls.
-          "integer value is also considered to be of type 'double'");
-    }
-  }
-}
-
-
 DEFINE_NATIVE_ENTRY(Object_instanceOf, 4) {
   const Instance& instance =
       Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
   const TypeArguments& instantiator_type_arguments =
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(1));
   const AbstractType& type =
       AbstractType::CheckedHandle(zone, arguments->NativeArgAt(2));
   const Bool& negate = Bool::CheckedHandle(zone, arguments->NativeArgAt(3));
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsMalformed());
   ASSERT(!type.IsMalbounded());
-
-  // Check for javascript compatibility.
-  if (FLAG_warn_on_javascript_compatibility) {
-    WarnOnJSIntegralNumTypeTest(instance, instantiator_type_arguments, type);
-  }
-
   Error& bound_error = Error::Handle(zone, Error::null());
   const bool is_instance_of = instance.IsInstanceOf(type,
                                                     instantiator_type_arguments,
                                                     &bound_error);
   if (FLAG_trace_type_checks) {
     const char* result_str = is_instance_of ? "true" : "false";
     OS::Print("Native Object.instanceOf: result %s\n", result_str);
     const AbstractType& instance_type =
         AbstractType::Handle(instance.GetType());
     OS::Print("  instance type: %s\n",
@@ skipping 86 matching lines @@
       TypeArguments::CheckedHandle(arguments->NativeArgAt(1));
   const AbstractType& type =
       AbstractType::CheckedHandle(arguments->NativeArgAt(2));
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsMalformed());
   ASSERT(!type.IsMalbounded());
   Error& bound_error = Error::Handle();
   if (instance.IsNull()) {
     return instance.raw();
   }
-
-  // Check for javascript compatibility.
-  if (FLAG_warn_on_javascript_compatibility) {
-    WarnOnJSIntegralNumTypeTest(instance, instantiator_type_arguments, type);
-  }
-
   const bool is_instance_of = instance.IsInstanceOf(type,
                                                     instantiator_type_arguments,
                                                     &bound_error);
   if (FLAG_trace_type_checks) {
     const char* result_str = is_instance_of ? "true" : "false";
     OS::Print("Object.as: result %s\n", result_str);
     const AbstractType& instance_type =
         AbstractType::Handle(instance.GetType());
     OS::Print("  instance type: %s\n",
               String::Handle(instance_type.Name()).ToCString());
@@ skipping 86 matching lines @@
 
 DEFINE_NATIVE_ENTRY(Internal_inquireIs64Bit, 0) {
 #if defined(ARCH_IS_64_BIT)
   return Bool::True().raw();
 #else
   return Bool::False().raw();
 #endif  // defined(ARCH_IS_64_BIT)
 }
 
 }  // namespace dart