What could cause JavaScript "new" keyword to fail?

Question

NOTE: I am using ES6 (classes)

So I am currently working on a WinJS Universal (UWP) application. I have found that most of the time my call (to a specific class) works without any issues. However when I call it rapidly the return value is the class itself. I know that the reference is not being changed because I can put a while loop just below it and it will start working again. It seems to be some sort of timing issue.

I will break on the following code:

var crop = new $js.Vector2(xCrop, yCrop);

if (!(crop instanceof $js.Vector2)) {
    debugger; // This is being hit (not 100% chance, only in rapid use)
}

However if I do the following:

var crop = new $js.Vector2(xCrop, yCrop);

while (!(crop instanceof $js.Vector2)) {
    crop = new $js.Vector2(xCrop, yCrop);
}

if (!(crop instanceof $js.Vector2)) {
    debugger; // This is never hit and the program continues as normal
}

The program will continue it's normal execution. Also when I use breakpoints around that part of the code to step through it, it works completely fine; this is what leads me to believe it is some timing issue. I am just trying to figure out if this is a bug on Microsoft's side or on my side.

Here is my $js.Vector2 code:

/**
 * A basic 2 dimensional vector
 * @class
 */
$js.Vector2 = class {

    /**
     * @constructor
     * @param {number} [x=0] The x dimension of the vector
     * @param {number} [y=0] The y dimension of the vector
     */
    constructor(x, y) {
        /**
        * The x dimension of this vector
        * @type {number}
        */
        this.x = x || 0;

        /**
         * The y dimension of this vector
         * @type {number}
         */
        this.y = y || 0;
    }

    /**
     * Copys the x and y dimension of a $js.Vector2 to this one
     * @param {number} x
     * @param {number} y
     */
    set(x, y) {
        if (x != null) {
            this.x = x;
        }

        if (y != null) {
            this.y = y;
        }
    }

    /**
     * Transposes this vector by another vector by shifting (adding)
     * @param {$js.Vector2} vector The vector to be added to this vector
     */
    move(vector) {
        this.x += vector.x;
        this.y += vector.y;
    }

    /**
     * Get's the magnitude (pythagorean theorem) of this vector (the length of the hypotenuse of the right triangle produced by this vector)
     * @return {number} The length of the hypotenuse
     */
    get magnitude() {
        return Math.sqrt((this.x * this.x) + (this.y * this.y))
    }

    /**
     * Get's the dot product of this vector and another
     * @param {$js.Vector2} vector The vector to be multiplied with this vector
     * @return {number} The result of dot product (vector multiplication)
     */
    dot(vector) {
        return (this.x * vector.x) + (this.y * vector.y);
    }

    /**
     * This will return a new normalized $js.Vector2 of this vector
     * @return {$js.Vector2} The normalized $js.Vector2
     */
    get normalized() {
        var tmp = new $js.Vector2(this.x, this.y);

        var mag = this.magnitude;
        tmp.x = tmp.x / mag;
        tmp.y = tmp.y / mag;

        return tmp;
    }

    /**
     * Will get the distance between this vector and another supplied vector
     * @param {$js.Vector2} vector
     * @return {number} The distance between this $js.Vector2 and the supplied $js.Vector2
     */
    distance(vector) {
        return Math.sqrt(((vector.x - this.x) * (vector.x - this.x)) + ((this.y - vector.y) * (this.y - vector.y)));
    }

    /**
     * Will subtract this vector from another vector
     * @param {$js.Vector2} vector
     * @return {$js.Vector2} The result of this vector subtracted by a supplied vector (in that order)
     */
    difference(vector) {
        return new $js.Vector2((this.x - vector.x), (this.y - vector.y));
    }

    /**
     * Will add this vector from another vector
     * @param {$js.Vector2} vector
     * @return {$js.Vector2} The result of this vector added by a supplied vector
     */
    sum(vector) {
        return new $js.Vector2((this.x + vector.x), (this.y + vector.y));
    }

    /**
     * Will check if this vector's components are equal to the supplied vectors
     * @param {$js.Vector2} vector The vector to compare against
     * @return {boolean} <c>true</c> if the x, y, and z of both vectors are the same value otherwise <c>false</c>
     */
    equals(vector) {
        if (!(vector instanceof $js.Vector2)) {
            return false;
        }

        return this.x === vector.x && this.y === vector.y;
    }
};

Any help would be appreciated. I would rather not have to do some hack work arounds to resolve this issue if they can be avoided.

Edit: I just ran this same exact code on my Surface Pro 3 and it worked without any issues. It seems to be an issue with my desktop (Intel Core i7-6700K processor). This perpetuates my assumption of it being a speed related issue, will see if there are any updates/patches from MS for VS related to this.

Answer 1

This may be a known issue: https://github.com/Microsoft/ChakraCore/issues/1496 https://github.com/Microsoft/ChakraCore/pull/1577 See if it reproduces on Windows Insider Preview.