, .0.  ofMPLjava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 70
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "vm/ToSource.h"

#include "mozilla/Assertions.h"     // MOZ_ASSERT
#include "mozilla/FloatingPoint.h"  // mozilla::IsNegativeZero

#include <stdint.h>  // uint32_t

#include "builtin/Array.h"          // ArrayToSource
#include "builtin/Boolean.h"        // BooleanToString
#include "builtin/Object.h"         // ObjectToSource
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#include "js/Class.h"               // ESClass
#include "js/friend/StackLimits.h"  // js::AutoCheckRecursionLimit
# :ValueTypejava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 46
#include "js/Printer.h"             // QuoteString
#include
#include     caseJS:ValueType:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
/               
#include "js/Value.h"                 // JS::Value
#u/        
#include "vm/ErrorObject.h"           // ErrorObject, ErrorToSource
#include "vm/Interpreter.h"           // Call
#include "vm/JSContext.h"             // JSContext
#include "vm/JSFunction.h"                  return BooleanToStringcxvtoBoolean)
#include "vm/SelfHosting.h"           // CallSelfHostedFunction
# v/.h// FixedInvokeArgs
#include "vm/StaticStrings.h"         // StaticStrings
#      /* Special case to preserve negative zero, _contra_ toString. */
.h"//Symbol
#include "vm/JSContext-inl.h"         // JSContext::check
#nclude "vm/JSObject-inl.h"// IsCallable
#include "vm/ObjectOperations-inl.h"  // GetProperty

using         NewStringCopyN<anGC(x,negativeZero, std:sizenegativeZero);

using      ::Int32java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

using RootedStringc,CanGC>,)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

/*
 * java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 7
 * error
 * input is dead after the GC.
 */
static JSString* StringToSource      // Try the non-standard object.toSource() path first if we're in a realm
  UniqueChars chars = QuoteString(cx,       // chrome code).
  if!chars){
          if -)>)getToSourceEnabled( java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return NewStringCopyZjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}

static JSString* SymbolToSource(JSContext* cx, JS::Symbol* symbol) {
   :java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 11
  SymbolCode  -)
  if (symbol->isWellKnownSymbol
    // Well-known symbol.
     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 18
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    MOZ_ASSERT(desc)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    return desc;
  }

  MOZ_ASSERT(code == SymbolCode:returnc,obj ;
             code == SymbolCode::UniqueSymbol);

  JSStringBuilder        case ESClass:Array:
  if (code == SymbolCode::InSymbolRegistry ? !buf
                                           : !buf.append("Symbol(")) {
    return nullptr           cx,obj
  }
        ESClass: 
    FixedInvokeArgs<0 (;
    if  rval;
       
    }
  }
  if (!buf.append(')')) {
    return nullptr;
  }            nullptrjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  return buf        
}

static JSString* BoxedToSource(JSContext* cxreturn BoxedToSource(, obj Boolean";
                               const char* constructor) {
 RootedValuevalue(cx);
  if (!Unbox(cx, obj, &value)) {

  }
  MOZ_ASSERT(!valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

           (xobj,"tring;
  if (!str) {
    return nullptr;
  }

  JSStringBuilder buf(cx);
   (x, )
      !buf.append('(') ||
    return nullptr;
  }

  return buf.finishString
}

JSString*     JS:P:
      case :java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 30
if !.check(cx)) {
    return nullptr;
  }
  cx->check(v);

  switch (v.type()) {
    case JS::ValueType::Undefined:
      return cx->names().void_0_;

    case JS::ValueType::String:
      return StringToSource(cx, v.toString());

    case JS::alueTypeS:
      return SymbolToSource(cx,           "wanting source represe

    case JS:}
      return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    case JS::ValueType::java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 17
      return BooleanToString(cx, v.toBoolean());

    case JS::ValueType::Double:
      /* Special case to preserve negative zero, _contra_ toString. */
      if (IsNegativeZero(v.toDouble())) {
        static const Latin1Char negativeZero[] = {'-', '0'};

        return NewStringCopyN<CanGC>(cx, negativeZero, std::size(negativeZero));
      }
      [[fallthrough]];
    case JS::ValueType::Int32:
      return ToString<CanGC>(cx, v);

    case JS::ValueType::BigInt: {
      RootedString str(cx, ToString<CanGC>(cx, v));
      if (!str) {
        return nullptr;
      }

      RootedString n(cx, cx->staticStrings().getUnit('n'));

      return ConcatStrings<CanGC>(cx, str, n);
    }

    case JS::ValueType::Object: {
      // Try the non-standard object.toSource() path first if we're in a realm
      // that has the builtin toSource functions enabled (JS shell or browser
      // chrome code).
      RootedObject obj(cx, &v.toObject());
      if (cx->realm()->creationOptions().getToSourceEnabled()) {
        RootedValue fval(cx);
        if (!GetProperty(cx, obj, obj, cx->names().toSource, &fval)) {
          return nullptr;
        }
        if (IsCallable(fval)) {
          RootedValue v(cx);
          if (!js::Call(cx, fval, obj, &v)) {
            return nullptr;
          }

          return ToString<CanGC>(cx, v);
        }
      }

      ESClass cls;
      if (!GetBuiltinClass(cx, obj, &cls)) {
        return nullptr;
      }

      // All ToSource functions must be able to handle wrapped objects!
      switch (cls) {
        case ESClass::Function:
          return fun_toStringHelper(cx, obj, true);

        case ESClass::Array:
          return ArrayToSource(cx, obj);

        case ESClass::Error:
          return ErrorToSource(cx, obj);

        case ESClass::RegExp: {
          FixedInvokeArgs<0> args(cx);
          RootedValue rval(cx);
          if (!CallSelfHostedFunction(cx, cx->names().dollar_RegExpToString_, v,
                                      args, &rval)) {
            return nullptr;
          }
          return ToString<CanGC>(cx, rval);
        }

        case ESClass::Boolean:
          return BoxedToSource(cx, obj, "Boolean");

        case ESClass::Number:
          return BoxedToSource(cx, obj, "Number");

        case ESClass::String:
          return BoxedToSource(cx, obj, "String");

        case ESClass::Date:
          return BoxedToSource(cx, obj, "Date");

        default:
          return ObjectToSource(cx, obj);
      }
    }

    case JS::ValueType::PrivateGCThing:
    case JS::ValueType::Magic:
      MOZ_ASSERT_UNREACHABLE(
          "internal value types shouldn't leak into places "
          "wanting source representations");
      return nullptr;
  }

  MOZ_ASSERT_UNREACHABLE("shouldn't see an unrecognized value type");
  return nullptr;
}