// 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.
// Test deoptimization.

import "package:expect/expect.dart";

class SmiCompares {
  // Test deoptimization when one argument is known to be Smi.
  static bool smiCompareLessThan2(a) {
    return a < 2;
  }

  // Test deoptimization when one argument is known to be Smi.
  static bool smiCompareGreaterThan2(a) {
    return 2 < a;
  }

  // Test deoptimization when both arguments unknown.
  static bool smiCompareLessThan(a, b) {
    return a < b;
  }

  // Test deoptimization when both arguments unknown.
  static bool smiCompareGreaterThan(a, b) {
    return a > b;
  }

  static smiComparesTest() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(true, smiCompareLessThan2(1));
      Expect.equals(false, smiCompareLessThan2(3));
      Expect.equals(false, smiCompareGreaterThan2(1));
      Expect.equals(true, smiCompareGreaterThan2(3));
      Expect.equals(true, smiCompareLessThan(1, 2));
      Expect.equals(false, smiCompareGreaterThan(1, 2));
    }
    // Deoptimize by passing a double instead of Smi
    Expect.equals(true, smiCompareLessThan2(1.0));
    Expect.equals(false, smiCompareGreaterThan2(1.0));
    Expect.equals(true, smiCompareLessThan(1.0, 2));
    Expect.equals(false, smiCompareGreaterThan(1, 2.0));
  }
}

class SmiBinop {
  static subWithLiteral(a) {
    return a - 1;
  }

  static void smiBinopTest() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(2, subWithLiteral(3));
    }
    // Deoptimize.
    Expect.equals(2.0, subWithLiteral(3.0));
  }

  static mul(x) {
    return x * 1024;
  }

  static void smiBinopOverflowTest() {
    final int big = 536870912;
    for (int i = 0; i < 2000; i++) {
      Expect.equals(1024, mul(1));
    }
    // Deoptimize by overflow.
    Expect.equals(1024 * big, mul(big));
  }
}

class ObjectsEquality {
  static bool compareEqual(a, b) {
    return a == b;
  }

  static bool compareNotEqual(a, b) {
    return a != b;
  }

  // Use only Object.==.
  static void objectsEqualityTest() {
    var a = new ObjectsEquality();
    var b = new ObjectsEquality();
    for (int i = 0; i < 1000; i++) {
      Expect.equals(true, compareEqual(a, a));
      Expect.equals(true, compareEqual(null, null));
      Expect.equals(false, compareEqual(null, a));
      Expect.equals(false, compareEqual(a, null));
      Expect.equals(true, compareEqual(b, b));
      Expect.equals(false, compareEqual(a, b));

      Expect.equals(false, compareNotEqual(a, a));
      Expect.equals(false, compareNotEqual(null, null));
      Expect.equals(true, compareNotEqual(null, a));
      Expect.equals(true, compareNotEqual(a, null));
      Expect.equals(false, compareNotEqual(b, b));
      Expect.equals(true, compareNotEqual(a, b));
    }
    var c = new SmiBinop();
    // Deoptimize.
    Expect.equals(true, compareEqual(c, c));
    Expect.equals(false, compareEqual(c, null));
    Expect.equals(false, compareNotEqual(c, c));
    Expect.equals(true, compareNotEqual(c, null));
  }
}

class DeoptimizationTest {
  static foo(a, b) {
    return a - b;
  }

  static test1() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(2, foo(3, 1)); // <-- Optimizes 'foo',
    }
    Expect.equals(2.2, foo(1.2, -1.0)); // <-- Deoptimizes 'foo'.
    for (int i = 0; i < 10000; i++) {
      Expect.equals(2, foo(3, 1)); // <-- Optimizes 'foo'.
    }
    Expect.equals(2.2, foo(1.2, -1)); // <-- Deoptimizes 'foo'.
  }

  static moo(n) {
    return ++n;
  }

  static test2() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(4, moo(3)); // <-- Optimizes 'moo',
    }
    Expect.equals(2.2, moo(1.2)); // <-- Deoptimizes 'moo'.
    for (int i = 0; i < 10000; i++) {
      Expect.equals(4, moo(3)); // <-- Optimizes 'moo'.
    }
    Expect.equals(2.2, moo(1.2)); // <-- Deoptimizes 'moo'.
  }

  static test3() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(2.0, foo(3.0, 1.0)); // <-- Optimizes 'foo',
    }
    Expect.equals(2, foo(1, -1)); // <-- Deoptimizes 'foo'.
    for (int i = 0; i < 2000; i++) {
      Expect.equals(2.0, foo(3.0, 1.0)); // <-- Optimizes 'foo',
    }
    Expect.equals(2.2, moo(1.2)); // <-- Deoptimizes 'moo'.
  }

  static bool compareInt(a, b) {
    return a < b;
  }

  static bool compareDouble(a, b) {
    return a < b;
  }

  static test4() {
    for (int i = 0; i < 2000; i++) {
      Expect.equals(true, compareInt(1, 2));
      Expect.equals(true, compareDouble(1.0, 2.0));
    }
    // Trigger deoptimization in compareInt and compareDouble.
    Expect.equals(true, compareInt(1, 2.0));
    Expect.equals(true, compareDouble(1.0, 2));
  }

  static smiRightShift() {
    int ShiftRight(int a, int b) {
      return a >> b;
    }

    for (int i = 0; i < 2000; i++) {
      var r = ShiftRight(10, 2);
      Expect.equals(2, r);
    }
    // ShiftRight is optimized.
    Expect.equals(0, ShiftRight(10, 64));
    // Deoptimize ShiftRight because 'a' is a Mint.
    var mint = 1 << 63;
    Expect.equals(-1 << 3, ShiftRight(mint, 60));
  }

  static doubleUnary() {
    num unary(num a) {
      return -a;
    }

    for (int i = 0; i < 2000; i++) {
      var r = unary(2.0);
      Expect.equals(-2.0, r);
    }
    var r = unary(5);
    Expect.equals(-5, r);
  }

  static void testMain() {
    test1();
    test2();
    test3();
    test4();
    SmiCompares.smiComparesTest();
    SmiBinop.smiBinopTest();
    SmiBinop.smiBinopOverflowTest();
    ObjectsEquality.objectsEqualityTest();
    smiRightShift();
    doubleUnary();
  }
}

main() {
  DeoptimizationTest.testMain();
}