JintBinaryExpression.cs 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918
  1. using System.Collections.Concurrent;
  2. using System.Diagnostics.CodeAnalysis;
  3. using System.Linq;
  4. using System.Numerics;
  5. using System.Reflection;
  6. using System.Runtime.CompilerServices;
  7. using Jint.Extensions;
  8. using Jint.Native;
  9. using Jint.Native.Number;
  10. using Jint.Native.Object;
  11. using Jint.Runtime.Interop;
  12. using Operator = Esprima.Ast.BinaryOperator;
  13. namespace Jint.Runtime.Interpreter.Expressions
  14. {
  15. internal abstract class JintBinaryExpression : JintExpression
  16. {
  17. private readonly record struct OperatorKey(string? OperatorName, Type Left, Type Right);
  18. private static readonly ConcurrentDictionary<OperatorKey, MethodDescriptor> _knownOperators = new();
  19. private JintExpression _left = null!;
  20. private JintExpression _right = null!;
  21. private bool _initialized;
  22. private JintBinaryExpression(BinaryExpression expression) : base(expression)
  23. {
  24. // TODO check https://tc39.es/ecma262/#sec-applystringornumericbinaryoperator
  25. }
  26. [MethodImpl(MethodImplOptions.AggressiveInlining)]
  27. private void EnsureInitialized()
  28. {
  29. if (_initialized)
  30. {
  31. return;
  32. }
  33. var expression = (BinaryExpression) _expression;
  34. _left = Build(expression.Left);
  35. _right = Build(expression.Right);
  36. _initialized = true;
  37. }
  38. internal static bool TryOperatorOverloading(
  39. EvaluationContext context,
  40. JsValue leftValue,
  41. JsValue rightValue,
  42. string? clrName,
  43. [NotNullWhen(true)] out object? result)
  44. {
  45. var left = leftValue.ToObject();
  46. var right = rightValue.ToObject();
  47. if (left != null && right != null)
  48. {
  49. var leftType = left.GetType();
  50. var rightType = right.GetType();
  51. var arguments = new[] { leftValue, rightValue };
  52. var key = new OperatorKey(clrName, leftType, rightType);
  53. var method = _knownOperators.GetOrAdd(key, _ =>
  54. {
  55. var leftMethods = leftType.GetOperatorOverloadMethods();
  56. var rightMethods = rightType.GetOperatorOverloadMethods();
  57. var methods = leftMethods.Concat(rightMethods).Where(x => string.Equals(x.Name, clrName, StringComparison.Ordinal) && x.GetParameters().Length == 2);
  58. var methodDescriptors = MethodDescriptor.Build(methods.ToArray());
  59. return InteropHelper.FindBestMatch(context.Engine, methodDescriptors, _ => arguments).FirstOrDefault().Method;
  60. });
  61. if (method != null)
  62. {
  63. try
  64. {
  65. result = method.Call(context.Engine, null, arguments);
  66. return true;
  67. }
  68. catch (Exception e)
  69. {
  70. ExceptionHelper.ThrowMeaningfulException(context.Engine, new TargetInvocationException(e.InnerException));
  71. result = null;
  72. return false;
  73. }
  74. }
  75. }
  76. result = null;
  77. return false;
  78. }
  79. internal static JintExpression Build(BinaryExpression expression)
  80. {
  81. JintBinaryExpression? result = null;
  82. switch (expression.Operator)
  83. {
  84. case Operator.StrictlyEqual:
  85. result = new StrictlyEqualBinaryExpression(expression);
  86. break;
  87. case Operator.StrictlyNotEqual:
  88. result = new StrictlyNotEqualBinaryExpression(expression);
  89. break;
  90. case Operator.Less:
  91. result = new LessBinaryExpression(expression);
  92. break;
  93. case Operator.Greater:
  94. result = new GreaterBinaryExpression(expression);
  95. break;
  96. case Operator.Plus:
  97. result = new PlusBinaryExpression(expression);
  98. break;
  99. case Operator.Minus:
  100. result = new MinusBinaryExpression(expression);
  101. break;
  102. case Operator.Times:
  103. result = new TimesBinaryExpression(expression);
  104. break;
  105. case Operator.Divide:
  106. result = new DivideBinaryExpression(expression);
  107. break;
  108. case Operator.Equal:
  109. result = new EqualBinaryExpression(expression);
  110. break;
  111. case Operator.NotEqual:
  112. result = new EqualBinaryExpression(expression, invert: true);
  113. break;
  114. case Operator.GreaterOrEqual:
  115. result = new CompareBinaryExpression(expression, leftFirst: true);
  116. break;
  117. case Operator.LessOrEqual:
  118. result = new CompareBinaryExpression(expression, leftFirst: false);
  119. break;
  120. case Operator.BitwiseAnd:
  121. case Operator.BitwiseOr:
  122. case Operator.BitwiseXor:
  123. case Operator.LeftShift:
  124. case Operator.RightShift:
  125. case Operator.UnsignedRightShift:
  126. result = new BitwiseBinaryExpression(expression);
  127. break;
  128. case Operator.InstanceOf:
  129. result = new InstanceOfBinaryExpression(expression);
  130. break;
  131. case Operator.Exponentiation:
  132. result = new ExponentiationBinaryExpression(expression);
  133. break;
  134. case Operator.Modulo:
  135. result = new ModuloBinaryExpression(expression);
  136. break;
  137. case Operator.In:
  138. result = new InBinaryExpression(expression);
  139. break;
  140. default:
  141. ExceptionHelper.ThrowArgumentOutOfRangeException(nameof(expression.Operator), "cannot handle operator");
  142. break;
  143. }
  144. if (expression.Operator != Operator.InstanceOf
  145. && expression.Operator != Operator.In
  146. && expression.Left is Literal leftLiteral
  147. && expression.Right is Literal rightLiteral)
  148. {
  149. var lval = JintLiteralExpression.ConvertToJsValue(leftLiteral);
  150. var rval = JintLiteralExpression.ConvertToJsValue(rightLiteral);
  151. if (lval is not null && rval is not null)
  152. {
  153. // we have fixed result
  154. try
  155. {
  156. var context = new EvaluationContext();
  157. return new JintConstantExpression(expression, (JsValue) result.EvaluateWithoutNodeTracking(context));
  158. }
  159. catch
  160. {
  161. // probably caused an error and error reporting doesn't work without engine
  162. }
  163. }
  164. }
  165. return result;
  166. }
  167. [MethodImpl(MethodImplOptions.AggressiveInlining)]
  168. internal static bool AreNonBigIntOperands(JsValue left, JsValue right)
  169. {
  170. return left._type != InternalTypes.BigInt && right._type != InternalTypes.BigInt;
  171. }
  172. internal static void AssertValidBigIntArithmeticOperands(JsValue left, JsValue right)
  173. {
  174. if (left.Type != right.Type)
  175. {
  176. ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions");
  177. }
  178. }
  179. private sealed class StrictlyEqualBinaryExpression : JintBinaryExpression
  180. {
  181. public StrictlyEqualBinaryExpression(BinaryExpression expression) : base(expression)
  182. {
  183. }
  184. protected override object EvaluateInternal(EvaluationContext context)
  185. {
  186. EnsureInitialized();
  187. var left = _left.GetValue(context);
  188. var right = _right.GetValue(context);
  189. var equal = left == right;
  190. return equal ? JsBoolean.True : JsBoolean.False;
  191. }
  192. }
  193. private sealed class StrictlyNotEqualBinaryExpression : JintBinaryExpression
  194. {
  195. public StrictlyNotEqualBinaryExpression(BinaryExpression expression) : base(expression)
  196. {
  197. }
  198. protected override object EvaluateInternal(EvaluationContext context)
  199. {
  200. EnsureInitialized();
  201. var left = _left.GetValue(context);
  202. var right = _right.GetValue(context);
  203. return left == right ? JsBoolean.False : JsBoolean.True;
  204. }
  205. }
  206. private sealed class LessBinaryExpression : JintBinaryExpression
  207. {
  208. public LessBinaryExpression(BinaryExpression expression) : base(expression)
  209. {
  210. }
  211. protected override object EvaluateInternal(EvaluationContext context)
  212. {
  213. EnsureInitialized();
  214. var left = _left.GetValue(context);
  215. var right = _right.GetValue(context);
  216. if (context.OperatorOverloadingAllowed
  217. && TryOperatorOverloading(context, left, right, "op_LessThan", out var opResult))
  218. {
  219. return JsValue.FromObject(context.Engine, opResult);
  220. }
  221. var value = Compare(left, right);
  222. return value._type == InternalTypes.Undefined ? JsBoolean.False : value;
  223. }
  224. }
  225. private sealed class GreaterBinaryExpression : JintBinaryExpression
  226. {
  227. public GreaterBinaryExpression(BinaryExpression expression) : base(expression)
  228. {
  229. }
  230. protected override object EvaluateInternal(EvaluationContext context)
  231. {
  232. EnsureInitialized();
  233. var left = _left.GetValue(context);
  234. var right = _right.GetValue(context);
  235. if (context.OperatorOverloadingAllowed
  236. && TryOperatorOverloading(context, left, right, "op_GreaterThan", out var opResult))
  237. {
  238. return JsValue.FromObject(context.Engine, opResult);
  239. }
  240. var value = Compare(right, left, false);
  241. return value._type == InternalTypes.Undefined ? JsBoolean.False : value;
  242. }
  243. }
  244. private sealed class PlusBinaryExpression : JintBinaryExpression
  245. {
  246. public PlusBinaryExpression(BinaryExpression expression) : base(expression)
  247. {
  248. }
  249. protected override object EvaluateInternal(EvaluationContext context)
  250. {
  251. EnsureInitialized();
  252. var left = _left.GetValue(context);
  253. var right = _right.GetValue(context);
  254. if (context.OperatorOverloadingAllowed
  255. && TryOperatorOverloading(context, left, right, "op_Addition", out var opResult))
  256. {
  257. return JsValue.FromObject(context.Engine, opResult);
  258. }
  259. if (AreIntegerOperands(left, right))
  260. {
  261. return JsNumber.Create((long)left.AsInteger() + right.AsInteger());
  262. }
  263. var lprim = TypeConverter.ToPrimitive(left);
  264. var rprim = TypeConverter.ToPrimitive(right);
  265. JsValue result;
  266. if (lprim.IsString() || rprim.IsString())
  267. {
  268. result = JsString.Create(TypeConverter.ToString(lprim) + TypeConverter.ToString(rprim));
  269. }
  270. else if (AreNonBigIntOperands(left,right))
  271. {
  272. result = JsNumber.Create(TypeConverter.ToNumber(lprim) + TypeConverter.ToNumber(rprim));
  273. }
  274. else
  275. {
  276. AssertValidBigIntArithmeticOperands(lprim, rprim);
  277. result = JsBigInt.Create(TypeConverter.ToBigInt(lprim) + TypeConverter.ToBigInt(rprim));
  278. }
  279. return result;
  280. }
  281. }
  282. private sealed class MinusBinaryExpression : JintBinaryExpression
  283. {
  284. public MinusBinaryExpression(BinaryExpression expression) : base(expression)
  285. {
  286. }
  287. protected override object EvaluateInternal(EvaluationContext context)
  288. {
  289. EnsureInitialized();
  290. var left = _left.GetValue(context);
  291. var right = _right.GetValue(context);
  292. if (context.OperatorOverloadingAllowed
  293. && TryOperatorOverloading(context, left, right, "op_Subtraction", out var opResult))
  294. {
  295. return JsValue.FromObject(context.Engine, opResult);
  296. }
  297. JsValue number;
  298. left = TypeConverter.ToNumeric(left);
  299. right = TypeConverter.ToNumeric(right);
  300. if (AreIntegerOperands(left, right))
  301. {
  302. number = JsNumber.Create((long)left.AsInteger() - right.AsInteger());
  303. }
  304. else if (AreNonBigIntOperands(left, right))
  305. {
  306. number = JsNumber.Create(left.AsNumber() - right.AsNumber());
  307. }
  308. else
  309. {
  310. number = JsBigInt.Create(TypeConverter.ToBigInt(left) - TypeConverter.ToBigInt(right));
  311. }
  312. return number;
  313. }
  314. }
  315. private sealed class TimesBinaryExpression : JintBinaryExpression
  316. {
  317. public TimesBinaryExpression(BinaryExpression expression) : base(expression)
  318. {
  319. }
  320. protected override object EvaluateInternal(EvaluationContext context)
  321. {
  322. EnsureInitialized();
  323. var left = _left.GetValue(context);
  324. var right = _right.GetValue(context);
  325. JsValue result;
  326. if (context.OperatorOverloadingAllowed
  327. && TryOperatorOverloading(context, left, right, "op_Multiply", out var opResult))
  328. {
  329. result = JsValue.FromObject(context.Engine, opResult);
  330. }
  331. else if (AreIntegerOperands(left, right))
  332. {
  333. result = JsNumber.Create((long) left.AsInteger() * right.AsInteger());
  334. }
  335. else
  336. {
  337. var leftNumeric = TypeConverter.ToNumeric(left);
  338. var rightNumeric = TypeConverter.ToNumeric(right);
  339. if (leftNumeric.IsNumber() && rightNumeric.IsNumber())
  340. {
  341. result = JsNumber.Create(leftNumeric.AsNumber() * rightNumeric.AsNumber());
  342. }
  343. else
  344. {
  345. AssertValidBigIntArithmeticOperands(leftNumeric, rightNumeric);
  346. result = JsBigInt.Create(leftNumeric.AsBigInt() * rightNumeric.AsBigInt());
  347. }
  348. }
  349. return result;
  350. }
  351. }
  352. private sealed class DivideBinaryExpression : JintBinaryExpression
  353. {
  354. public DivideBinaryExpression(BinaryExpression expression) : base(expression)
  355. {
  356. }
  357. protected override object EvaluateInternal(EvaluationContext context)
  358. {
  359. EnsureInitialized();
  360. var left = _left.GetValue(context);
  361. var right = _right.GetValue(context);
  362. if (context.OperatorOverloadingAllowed
  363. && TryOperatorOverloading(context, left, right, "op_Division", out var opResult))
  364. {
  365. return JsValue.FromObject(context.Engine, opResult);
  366. }
  367. left = TypeConverter.ToNumeric(left);
  368. right = TypeConverter.ToNumeric(right);
  369. return Divide(context, left, right);
  370. }
  371. }
  372. private sealed class EqualBinaryExpression : JintBinaryExpression
  373. {
  374. private readonly bool _invert;
  375. public EqualBinaryExpression(BinaryExpression expression, bool invert = false) : base(expression)
  376. {
  377. _invert = invert;
  378. }
  379. protected override object EvaluateInternal(EvaluationContext context)
  380. {
  381. EnsureInitialized();
  382. var left = _left.GetValue(context);
  383. var right = _right.GetValue(context);
  384. if (context.OperatorOverloadingAllowed
  385. && TryOperatorOverloading(context, left, right, _invert ? "op_Inequality" : "op_Equality", out var opResult))
  386. {
  387. return JsValue.FromObject(context.Engine, opResult);
  388. }
  389. // if types match, we can take faster strict equality
  390. var equality = left.Type == right.Type
  391. ? left.Equals(right)
  392. : left.IsLooselyEqual(right);
  393. return equality == !_invert ? JsBoolean.True : JsBoolean.False;
  394. }
  395. }
  396. private sealed class CompareBinaryExpression : JintBinaryExpression
  397. {
  398. private readonly bool _leftFirst;
  399. public CompareBinaryExpression(BinaryExpression expression, bool leftFirst) : base(expression)
  400. {
  401. _leftFirst = leftFirst;
  402. }
  403. protected override object EvaluateInternal(EvaluationContext context)
  404. {
  405. EnsureInitialized();
  406. var leftValue = _left.GetValue(context);
  407. var rightValue = _right.GetValue(context);
  408. if (context.OperatorOverloadingAllowed
  409. && TryOperatorOverloading(context, leftValue, rightValue, _leftFirst ? "op_GreaterThanOrEqual" : "op_LessThanOrEqual", out var opResult))
  410. {
  411. return JsValue.FromObject(context.Engine, opResult);
  412. }
  413. var left = _leftFirst ? leftValue : rightValue;
  414. var right = _leftFirst ? rightValue : leftValue;
  415. var value = Compare(left, right, _leftFirst);
  416. return value.IsUndefined() || ((JsBoolean) value)._value ? JsBoolean.False : JsBoolean.True;
  417. }
  418. }
  419. private sealed class InstanceOfBinaryExpression : JintBinaryExpression
  420. {
  421. public InstanceOfBinaryExpression(BinaryExpression expression) : base(expression)
  422. {
  423. }
  424. protected override object EvaluateInternal(EvaluationContext context)
  425. {
  426. EnsureInitialized();
  427. var leftValue = _left.GetValue(context);
  428. var rightValue = _right.GetValue(context);
  429. return leftValue.InstanceofOperator(rightValue) ? JsBoolean.True : JsBoolean.False;
  430. }
  431. }
  432. private sealed class ExponentiationBinaryExpression : JintBinaryExpression
  433. {
  434. public ExponentiationBinaryExpression(BinaryExpression expression) : base(expression)
  435. {
  436. }
  437. protected override object EvaluateInternal(EvaluationContext context)
  438. {
  439. EnsureInitialized();
  440. var leftReference = _left.GetValue(context);
  441. var rightReference = _right.GetValue(context);
  442. var left = TypeConverter.ToNumeric(leftReference);
  443. var right = TypeConverter.ToNumeric(rightReference);
  444. JsValue result;
  445. if (AreNonBigIntOperands(left,right))
  446. {
  447. // validation
  448. var baseNumber = (JsNumber) left;
  449. var exponentNumber = (JsNumber) right;
  450. if (exponentNumber.IsNaN())
  451. {
  452. return JsNumber.DoubleNaN;
  453. }
  454. if (exponentNumber.IsZero())
  455. {
  456. return JsNumber.PositiveOne;
  457. }
  458. if (baseNumber.IsNaN())
  459. {
  460. return JsNumber.DoubleNaN;
  461. }
  462. var exponentValue = exponentNumber._value;
  463. if (baseNumber.IsPositiveInfinity())
  464. {
  465. return exponentValue > 0 ? JsNumber.DoublePositiveInfinity : JsNumber.PositiveZero;
  466. }
  467. static bool IsOddIntegral(double value) => TypeConverter.IsIntegralNumber(value) && value % 2 != 0;
  468. if (baseNumber.IsNegativeInfinity())
  469. {
  470. if (exponentValue > 0)
  471. {
  472. return IsOddIntegral(exponentValue) ? JsNumber.DoubleNegativeInfinity : JsNumber.DoublePositiveInfinity;
  473. }
  474. return IsOddIntegral(exponentValue) ? JsNumber.NegativeZero : JsNumber.PositiveZero;
  475. }
  476. if (baseNumber.IsPositiveZero())
  477. {
  478. return exponentValue > 0 ? JsNumber.PositiveZero : JsNumber.DoublePositiveInfinity;
  479. }
  480. if (baseNumber.IsNegativeZero())
  481. {
  482. if (exponentValue > 0)
  483. {
  484. return IsOddIntegral(exponentValue) ? JsNumber.NegativeZero : JsNumber.PositiveZero;
  485. }
  486. return IsOddIntegral(exponentValue) ? JsNumber.DoubleNegativeInfinity : JsNumber.DoublePositiveInfinity;
  487. }
  488. var baseValue = baseNumber._value;
  489. if (exponentNumber.IsPositiveInfinity())
  490. {
  491. if (Math.Abs(baseValue) > 1)
  492. {
  493. return JsNumber.DoublePositiveInfinity;
  494. }
  495. if (Math.Abs(baseValue) == 1)
  496. {
  497. return JsNumber.DoubleNaN;
  498. }
  499. return JsNumber.PositiveZero;
  500. }
  501. if (exponentNumber.IsNegativeInfinity())
  502. {
  503. if (Math.Abs(baseValue) > 1)
  504. {
  505. return JsNumber.PositiveZero;
  506. }
  507. if (Math.Abs(baseValue) == 1)
  508. {
  509. return JsNumber.DoubleNaN;
  510. }
  511. return JsNumber.DoublePositiveInfinity;
  512. }
  513. if (baseValue < 0 && !TypeConverter.IsIntegralNumber(exponentValue))
  514. {
  515. return JsNumber.DoubleNaN;
  516. }
  517. result = JsNumber.Create(Math.Pow(baseNumber._value, exponentValue));
  518. }
  519. else
  520. {
  521. AssertValidBigIntArithmeticOperands(left, right);
  522. var exponent = right.AsBigInt();
  523. if (exponent < 0)
  524. {
  525. ExceptionHelper.ThrowRangeError(context.Engine.Realm, "Exponent must be positive");
  526. }
  527. if (exponent > int.MaxValue || exponent < int.MinValue)
  528. {
  529. ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Exponent does not fit 32bit range");
  530. }
  531. result = JsBigInt.Create(BigInteger.Pow(left.AsBigInt(), (int) exponent));
  532. }
  533. return result;
  534. }
  535. }
  536. private sealed class InBinaryExpression : JintBinaryExpression
  537. {
  538. public InBinaryExpression(BinaryExpression expression) : base(expression)
  539. {
  540. }
  541. protected override object EvaluateInternal(EvaluationContext context)
  542. {
  543. EnsureInitialized();
  544. var left = _left.GetValue(context);
  545. var right = _right.GetValue(context);
  546. var oi = right as ObjectInstance;
  547. if (oi is null)
  548. {
  549. ExceptionHelper.ThrowTypeError(context.Engine.Realm, "in can only be used with an object");
  550. }
  551. if (left.IsPrivateName())
  552. {
  553. var privateEnv = context.Engine.ExecutionContext.PrivateEnvironment!;
  554. var privateName = privateEnv.ResolvePrivateIdentifier(((PrivateName) left).ToString());
  555. return privateName is not null && oi.PrivateElementFind(privateName) is not null ? JsBoolean.True : JsBoolean.False;
  556. }
  557. return oi.HasProperty(left) ? JsBoolean.True : JsBoolean.False;
  558. }
  559. }
  560. private sealed class ModuloBinaryExpression : JintBinaryExpression
  561. {
  562. public ModuloBinaryExpression(BinaryExpression expression) : base(expression)
  563. {
  564. }
  565. protected override object EvaluateInternal(EvaluationContext context)
  566. {
  567. EnsureInitialized();
  568. var left = _left.GetValue(context);
  569. var right = _right.GetValue(context);
  570. if (context.OperatorOverloadingAllowed
  571. && TryOperatorOverloading(context, left, right, "op_Modulus", out var opResult))
  572. {
  573. return JsValue.FromObject(context.Engine, opResult);
  574. }
  575. var result = JsValue.Undefined;
  576. left = TypeConverter.ToNumeric(left);
  577. right = TypeConverter.ToNumeric(right);
  578. if (AreIntegerOperands(left, right))
  579. {
  580. var leftInteger = left.AsInteger();
  581. var rightInteger = right.AsInteger();
  582. if (rightInteger == 0)
  583. {
  584. result = JsNumber.DoubleNaN;
  585. }
  586. else
  587. {
  588. var modulo = leftInteger % rightInteger;
  589. if (modulo == 0 && leftInteger < 0)
  590. {
  591. result = JsNumber.NegativeZero;
  592. }
  593. else
  594. {
  595. result = JsNumber.Create(modulo);
  596. }
  597. }
  598. }
  599. else if (AreNonBigIntOperands(left, right))
  600. {
  601. var n = left.AsNumber();
  602. var d = right.AsNumber();
  603. if (double.IsNaN(n) || double.IsNaN(d) || double.IsInfinity(n))
  604. {
  605. result = JsNumber.DoubleNaN;
  606. }
  607. else if (double.IsInfinity(d))
  608. {
  609. result = n;
  610. }
  611. else if (NumberInstance.IsPositiveZero(d) || NumberInstance.IsNegativeZero(d))
  612. {
  613. result = JsNumber.DoubleNaN;
  614. }
  615. else if (NumberInstance.IsPositiveZero(n) || NumberInstance.IsNegativeZero(n))
  616. {
  617. result = n;
  618. }
  619. else
  620. {
  621. result = JsNumber.Create(n % d);
  622. }
  623. }
  624. else
  625. {
  626. AssertValidBigIntArithmeticOperands(left, right);
  627. var n = TypeConverter.ToBigInt(left);
  628. var d = TypeConverter.ToBigInt(right);
  629. if (d == 0)
  630. {
  631. ExceptionHelper.ThrowRangeError(context.Engine.Realm, "Division by zero");
  632. }
  633. else if (n == 0)
  634. {
  635. result = JsBigInt.Zero;
  636. }
  637. else
  638. {
  639. result = JsBigInt.Create(n % d);
  640. }
  641. }
  642. return result;
  643. }
  644. }
  645. private sealed class BitwiseBinaryExpression : JintBinaryExpression
  646. {
  647. private string? OperatorClrName
  648. {
  649. get
  650. {
  651. return _operator switch
  652. {
  653. Operator.BitwiseAnd => "op_BitwiseAnd",
  654. Operator.BitwiseOr => "op_BitwiseOr",
  655. Operator.BitwiseXor => "op_ExclusiveOr",
  656. Operator.LeftShift => "op_LeftShift",
  657. Operator.RightShift => "op_RightShift",
  658. Operator.UnsignedRightShift => "op_UnsignedRightShift",
  659. _ => null
  660. };
  661. }
  662. }
  663. private readonly Operator _operator;
  664. public BitwiseBinaryExpression(BinaryExpression expression) : base(expression)
  665. {
  666. _operator = expression.Operator;
  667. }
  668. protected override object EvaluateInternal(EvaluationContext context)
  669. {
  670. EnsureInitialized();
  671. var lval = _left.GetValue(context);
  672. var rval = _right.GetValue(context);
  673. if (context.OperatorOverloadingAllowed
  674. && TryOperatorOverloading(context, lval, rval, OperatorClrName, out var opResult))
  675. {
  676. return JsValue.FromObject(context.Engine, opResult);
  677. }
  678. var lnum = TypeConverter.ToNumeric(lval);
  679. var rnum = TypeConverter.ToNumeric(rval);
  680. if (lnum.Type != rnum.Type)
  681. {
  682. ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", _left._expression);
  683. }
  684. if (AreIntegerOperands(lnum, rnum))
  685. {
  686. int leftValue = lnum.AsInteger();
  687. int rightValue = rnum.AsInteger();
  688. JsValue? result = null;
  689. switch (_operator)
  690. {
  691. case Operator.BitwiseAnd:
  692. result = JsNumber.Create(leftValue & rightValue);
  693. break;
  694. case Operator.BitwiseOr:
  695. result = JsNumber.Create(leftValue | rightValue);
  696. break;
  697. case Operator.BitwiseXor:
  698. result = JsNumber.Create(leftValue ^ rightValue);
  699. break;
  700. case Operator.LeftShift:
  701. result = JsNumber.Create(leftValue << (int) ((uint) rightValue & 0x1F));
  702. break;
  703. case Operator.RightShift:
  704. result = JsNumber.Create(leftValue >> (int) ((uint) rightValue & 0x1F));
  705. break;
  706. case Operator.UnsignedRightShift:
  707. result = JsNumber.Create((uint) leftValue >> (int) ((uint) rightValue & 0x1F));
  708. break;
  709. default:
  710. ExceptionHelper.ThrowArgumentOutOfRangeException(nameof(_operator), "unknown shift operator");
  711. break;
  712. }
  713. return result;
  714. }
  715. return EvaluateNonInteger(lnum, rnum);
  716. }
  717. private JsValue EvaluateNonInteger(JsValue left, JsValue right)
  718. {
  719. switch (_operator)
  720. {
  721. case Operator.BitwiseAnd:
  722. {
  723. if (!left.IsBigInt())
  724. {
  725. return JsNumber.Create(TypeConverter.ToInt32(left) & TypeConverter.ToInt32(right));
  726. }
  727. return JsBigInt.Create(TypeConverter.ToBigInt(left) & TypeConverter.ToBigInt(right));
  728. }
  729. case Operator.BitwiseOr:
  730. {
  731. if (!left.IsBigInt())
  732. {
  733. return JsNumber.Create(TypeConverter.ToInt32(left) | TypeConverter.ToInt32(right));
  734. }
  735. return JsBigInt.Create(TypeConverter.ToBigInt(left) | TypeConverter.ToBigInt(right));
  736. }
  737. case Operator.BitwiseXor:
  738. {
  739. if (!left.IsBigInt())
  740. {
  741. return JsNumber.Create(TypeConverter.ToInt32(left) ^ TypeConverter.ToInt32(right));
  742. }
  743. return JsBigInt.Create(TypeConverter.ToBigInt(left) ^ TypeConverter.ToBigInt(right));
  744. }
  745. case Operator.LeftShift:
  746. {
  747. if (!left.IsBigInt())
  748. {
  749. return JsNumber.Create(TypeConverter.ToInt32(left) << (int) (TypeConverter.ToUint32(right) & 0x1F));
  750. }
  751. return JsBigInt.Create(TypeConverter.ToBigInt(left) << (int) TypeConverter.ToBigInt(right));
  752. }
  753. case Operator.RightShift:
  754. {
  755. if (!left.IsBigInt())
  756. {
  757. return JsNumber.Create(TypeConverter.ToInt32(left) >> (int) (TypeConverter.ToUint32(right) & 0x1F));
  758. }
  759. return JsBigInt.Create(TypeConverter.ToBigInt(left) >> (int) TypeConverter.ToBigInt(right));
  760. }
  761. case Operator.UnsignedRightShift:
  762. {
  763. if (!left.IsBigInt())
  764. {
  765. return JsNumber.Create((uint) TypeConverter.ToInt32(left) >> (int) (TypeConverter.ToUint32(right) & 0x1F));
  766. }
  767. ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", _left._expression);
  768. return null;
  769. }
  770. default:
  771. {
  772. ExceptionHelper.ThrowArgumentOutOfRangeException(nameof(_operator), "unknown shift operator");
  773. return null;
  774. }
  775. }
  776. }
  777. }
  778. }
  779. }