Add tests for exponentiation

tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts

@@ -0,0 +1,26 @@
+enum E { a, b, c }
+
+var a: any;
+var b: number;
+var c: E;
+
+var x1: any;
+x1 **= a;
+x1 **= b;
+x1 **= c;
+x1 **= null;
+x1 **= undefined;
+
+var x2: number;
+x2 **= a;
+x2 **= b;
+x2 **= c;
+x2 **= null;
+x2 **= undefined;
+
+var x3: E;
+x3 **= a;
+x3 **= b;
+x3 **= c;
+x3 **= null;
+x3 **= undefined;

tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned2.ts

@@ -0,0 +1,60 @@
+enum E { a, b }
+
+var a: any;
+var b: void;
+
+var x1: boolean;
+x1 **= a;
+x1 **= b;
+x1 **= true;
+x1 **= 0;
+x1 **= ''
+x1 **= E.a;
+x1 **= {};
+x1 **= null;
+x1 **= undefined;
+
+var x2: string;
+x2 **= a;
+x2 **= b;
+x2 **= true;
+x2 **= 0;
+x2 **= ''
+x2 **= E.a;
+x2 **= {};
+x2 **= null;
+x2 **= undefined;
+
+var x3: {};
+x3 **= a;
+x3 **= b;
+x3 **= true;
+x3 **= 0;
+x3 **= ''
+x3 **= E.a;
+x3 **= {};
+x3 **= null;
+x3 **= undefined;
+
+var x4: void;
+x4 **= a;
+x4 **= b;
+x4 **= true;
+x4 **= 0;
+x4 **= ''
+x4 **= E.a;
+x4 **= {};
+x4 **= null;
+x4 **= undefined;
+
+var x5: number;
+x5 **= b;
+x5 **= true;
+x5 **= ''
+x5 **= {};
+
+var x6: E;
+x6 *= b;
+x6 *= true;
+x6 *= ''
+x6 *= {};

tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts

@@ -0,0 +1,26 @@
+var value;
+
+// identifiers: variable and parameter
+var x1: number;
+x1 **= value;
+
+function fn1(x2: number) {
+    x2 **= value;
+}
+
+// property accesses
+var x3: { a: number };
+x3.a **= value;
+
+x3['a'] **= value;
+
+// parentheses, the contained expression is reference
+(x1) **= value;
+
+function fn2(x4: number) {
+    (x4) **= value;
+}
+
+(x3.a) **= value;
+
+(x3['a']) **= value;

tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts

@@ -0,0 +1,85 @@
+// expected error for all the LHS of compound assignments (arithmetic and addition)
+var value;
+
+// this
+class C {
+    constructor() {
+        this **= value;
+    }
+    foo() {
+        this **= value;
+    }
+    static sfoo() {
+        this **= value;
+    }
+}
+
+function foo() {
+    this **= value;
+}
+
+this **= value;
+
+// identifiers: module, class, enum, function
+module M { export var a; }
+M **= value;
+
+C **= value;
+
+enum E { }
+E **= value;
+
+foo **= value;
+
+// literals
+null **= value;
+true **= value;
+false **= value;
+0 **= value;
+'' **= value;
+/d+/ **= value;
+
+// object literals
+{ a: 0 } **= value;
+
+// array literals
+['', ''] **= value;
+
+// super
+class Derived extends C {
+    constructor() {
+        super();
+        super **= value;
+    }
+
+    foo() {
+        super **= value;
+    }
+
+    static sfoo() {
+        super **= value;
+    }
+}
+
+// function expression
+function bar1() { } **= value;
+() => { } **= value;
+
+// function calls
+foo() **= value;
+
+// parentheses, the containted expression is value
+(this) **= value;
+(M) **= value;
+(C) **= value;
+(E) **= value;
+(foo) **= value;
+(null) **= value;
+(true) **= value;
+(0) **= value;
+('') **= value;
+(/d+/) **= value;
+({}) **= value;
+([]) **= value;
+(function baz1() { }) **= value;
+(foo()) **= value;

tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts

@@ -0,0 +1,20 @@
+var comp: number;
+
+comp **= 1;
+comp **= comp ** comp;
+comp **= comp ** comp ** 2;
+comp **= comp ** comp + 2;
+comp **= comp ** comp - 2;
+comp **= comp ** comp * 2;
+comp **= comp ** comp / 2;
+comp **= comp ** comp % 2;
+comp **= (comp - 2) ** 5;
+comp **= (comp + 2) ** 5;
+comp **= (comp * 2) ** 5;
+comp **= (comp / 2) ** 5;
+comp **= (comp % 2) ** 5;
+comp **= comp ** (5 + 2);
+comp **= comp ** (5 - 2);
+comp **= comp ** (5 * 2);
+comp **= comp ** (5 / 2);
+comp **= comp ** (5 % 2);

tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts

@@ -0,0 +1,32 @@
+// @target: es5
+
+1 ** 2;
+1 ** 2 ** 3;
+1 ** -2 ** 3;
+1 ** -2 ** -3;
+-1 ** -2 ** -3;
+-(1 ** 2) ** 3;
+1 ** -(2 ** 3);
+
+1 ** 2 + 3;
+1 ** 2 - 3;
+1 ** 2 * 3;
+1 ** 2 / 3;
+1 ** 2 % 3;
+
+1 ** -2 + 3;
+1 ** -2 - 3;
+1 ** -2 * 3;
+1 ** -2 / 3;
+1 ** -2 % 3;
+
+2 + 3 ** 3;
+2 - 3 ** 3;
+2 * 3 ** 3;
+2 / 3 ** 3;
+2 % 3 ** 3;
+
+(2 + 3) ** 4;
+(2 - 3) ** 4;
+(2 * 3) ** 4;
+(2 / 3) ** 4;

tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts

@@ -0,0 +1,32 @@
+// @target:es5
+
+var temp = 10;
+
+++temp ** 3;
+--temp ** 3;
+3 ** ++temp;
+3 ** --temp;
+
+--temp + 2 ** 3;
+--temp - 2 ** 3;
+--temp * 2 ** 3;
+--temp / 2 ** 3;
+--temp % 2 ** 3;
+
+++temp + 2 ** 3;
+++temp - 2 ** 3;
+++temp * 2 ** 3;
+++temp / 2 ** 3;
+++temp % 2 ** 3;
+
+3 ** ++temp + 2;
+3 ** ++temp - 2;
+3 ** ++temp * 2;
+3 ** ++temp / 2;
+3 ** ++temp % 2;
+
+3 ** --temp + 2;
+3 ** --temp - 2;
+3 ** --temp * 2;
+3 ** --temp / 2;
+3 ** --temp % 2;

tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts

@@ -0,0 +1,10 @@
+var t1 = 10;
+var t2 = 10;
+console.log(`${t1 ** t2}`)
+console.log(`${t1 ** t2 ** t1}`)
+console.log(`${t1 + t2 ** t1}`)
+console.log(`${t1 - t2 ** t1}`)
+console.log(`${t1 ** t2 + t1}`)
+console.log(`${t1 ** t2 - t1}`)
+console.log(`${t1 + t2 ** t2 + t1}`)
+console.log(`${t1 - t2 ** t2 - t1}`)

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts

@@ -0,0 +1,12 @@
+var a: any;
+var b: number;
+
+// operator **
+var r1 = a ** a;
+var r2 = a ** b;
+var r3 = a ** 0;
+var r4 = 0 ** a;
+var r5 = 0 ** 0;
+var r6 = b ** 0;
+var r7 = 0 ** b;
+var r8 = b ** b;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts

@@ -0,0 +1,24 @@
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+var c: E;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts

@@ -0,0 +1,28 @@
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+enum F {
+    c,
+    d
+}
+
+var a: any;
+var b: number;
+var c: E | F;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts

@@ -0,0 +1,68 @@
+// these operators require their operands to be of type Any, the Number primitive type, or
+// an enum type
+enum E { a, b, c }
+
+var a: any;
+var b: boolean;
+var c: number;
+var d: string;
+var e: { a: number };
+var f: Number;
+
+// All of the below should be an error unless otherwise noted
+// operator **
+var r1a1 = a ** a; //ok
+var r1a2 = a ** b;
+var r1a3 = a ** c; //ok
+var r1a4 = a ** d;
+var r1a5 = a ** e;
+var r1a6 = a ** f;
+
+var r1b1 = b ** a;
+var r1b2 = b ** b;
+var r1b3 = b ** c;
+var r1b4 = b ** d;
+var r1b5 = b ** e;
+var r1b6 = b ** f;
+
+var r1c1 = c ** a; //ok
+var r1c2 = c ** b;
+var r1c3 = c ** c; //ok
+var r1c4 = c ** d;
+var r1c5 = c ** e;
+var r1c6 = c ** f;
+
+var r1d1 = d ** a;
+var r1d2 = d ** b;
+var r1d3 = d ** c;
+var r1d4 = d ** d;
+var r1d5 = d ** e;
+var r1d6 = d ** f;
+
+var r1e1 = e ** a;
+var r1e2 = e ** b;
+var r1e3 = e ** c;
+var r1e4 = e ** d;
+var r1e5 = e ** e;
+var r1e6 = e ** f;
+
+var r1f1 = f ** a;
+var r1f2 = f ** b;
+var r1f3 = f ** c;
+var r1f4 = f ** d;
+var r1f5 = f ** e;
+var r1f6 = f ** f;
+
+var r1g1 = E.a ** a; //ok
+var r1g2 = E.a ** b;
+var r1g3 = E.a ** c; //ok
+var r1g4 = E.a ** d;
+var r1g5 = E.a ** e;
+var r1g6 = E.a ** f;
+
+var r1h1 = a ** E.b; //ok
+var r1h2 = b ** E.b;
+var r1h3 = c ** E.b; //ok
+var r1h4 = d ** E.b;
+var r1h5 = e ** E.b;
+var r1h6 = f ** E.b

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts

@@ -0,0 +1,23 @@
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = null ** a;
+var r1a2 = null ** b;
+var r1a3 = null ** c;
+
+var r1b1 = a ** null;
+var r1b2 = b ** null;
+var r1b3 = c ** null;
+
+var r1c1 = null ** true;
+var r1c2 = null ** '';
+var r1c3 = null ** {};
+
+var r1d1 = true ** null;
+var r1d2 = '' ** null;
+var r1d3 = {} ** null;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts

@@ -0,0 +1,20 @@
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator **
+var r1 = null ** a;
+var r2 = null ** b;
+var r3 = null ** 1;
+var r4 = null ** E.a;
+var r5 = a ** null;
+var r6 = b ** null;
+var r7 = 0 ** null;
+var r8 = E.b ** null;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts

@@ -0,0 +1,5 @@
+// operator **
+var r1 = null ** null;
+var r2 = null ** undefined;
+var r3 = undefined ** null;
+var r4 = undefined ** undefined;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts

@@ -0,0 +1,20 @@
+// type parameter type is not valid for arithmetic operand
+function foo<T>(t: T) {
+    var a: any;
+    var b: boolean;
+    var c: number;
+    var d: string;
+    var e: {};
+
+    var r1a1 = a ** t;
+    var r2a1 = t ** a;
+    var r1b1 = b ** t;
+    var r2b1 = t ** b;
+    var r1c1 = c ** t;
+    var r2c1 = t ** c;
+    var r1d1 = d ** t;
+    var r2d1 = t ** d;
+    var r1e1 = e ** t;
+    var r2e1 = t ** d;
+    var r1f1 = t ** t;
+}

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts

@@ -0,0 +1,23 @@
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = undefined ** a;
+var r1a2 = undefined ** b;
+var r1a3 = undefined ** c;
+
+var r1b1 = a ** undefined;
+var r1b2 = b ** undefined;
+var r1b3 = c ** undefined;
+
+var r1c1 = undefined ** true;
+var r1c2 = undefined ** '';
+var r1c3 = undefined ** {};
+
+var r1d1 = true ** undefined;
+var r1d2 = '' ** undefined;
+var r1d3 = {} ** undefined;

tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts

@@ -0,0 +1,120 @@
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator *
+var ra1 = undefined * a;
+var ra2 = undefined * b;
+var ra3 = undefined * 1;
+var ra4 = undefined * E.a;
+var ra5 = a * undefined;
+var ra6 = b * undefined;
+var ra7 = 0 * undefined;
+var ra8 = E.b * undefined;
+
+// operator /
+var rb1 = undefined / a;
+var rb2 = undefined / b;
+var rb3 = undefined / 1;
+var rb4 = undefined / E.a;
+var rb5 = a / undefined;
+var rb6 = b / undefined;
+var rb7 = 0 / undefined;
+var rb8 = E.b / undefined;
+
+// operator %
+var rc1 = undefined % a;
+var rc2 = undefined % b;
+var rc3 = undefined % 1;
+var rc4 = undefined % E.a;
+var rc5 = a % undefined;
+var rc6 = b % undefined;
+var rc7 = 0 % undefined;
+var rc8 = E.b % undefined;
+
+// operator -
+var rd1 = undefined - a;
+var rd2 = undefined - b;
+var rd3 = undefined - 1;
+var rd4 = undefined - E.a;
+var rd5 = a - undefined;
+var rd6 = b - undefined;
+var rd7 = 0 - undefined;
+var rd8 = E.b - undefined;
+
+// operator <<
+var re1 = undefined << a;
+var re2 = undefined << b;
+var re3 = undefined << 1;
+var re4 = undefined << E.a;
+var re5 = a << undefined;
+var re6 = b << undefined;
+var re7 = 0 << undefined;
+var re8 = E.b << undefined;
+
+// operator >>
+var rf1 = undefined >> a;
+var rf2 = undefined >> b;
+var rf3 = undefined >> 1;
+var rf4 = undefined >> E.a;
+var rf5 = a >> undefined;
+var rf6 = b >> undefined;
+var rf7 = 0 >> undefined;
+var rf8 = E.b >> undefined;
+
+// operator >>>
+var rg1 = undefined >>> a;
+var rg2 = undefined >>> b;
+var rg3 = undefined >>> 1;
+var rg4 = undefined >>> E.a;
+var rg5 = a >>> undefined;
+var rg6 = b >>> undefined;
+var rg7 = 0 >>> undefined;
+var rg8 = E.b >>> undefined;
+
+// operator &
+var rh1 = undefined & a;
+var rh2 = undefined & b;
+var rh3 = undefined & 1;
+var rh4 = undefined & E.a;
+var rh5 = a & undefined;
+var rh6 = b & undefined;
+var rh7 = 0 & undefined;
+var rh8 = E.b & undefined;
+
+// operator ^
+var ri1 = undefined ^ a;
+var ri2 = undefined ^ b;
+var ri3 = undefined ^ 1;
+var ri4 = undefined ^ E.a;
+var ri5 = a ^ undefined;
+var ri6 = b ^ undefined;
+var ri7 = 0 ^ undefined;
+var ri8 = E.b ^ undefined;
+
+// operator |
+var rj1 = undefined | a;
+var rj2 = undefined | b;
+var rj3 = undefined | 1;
+var rj4 = undefined | E.a;
+var rj5 = a | undefined;
+var rj6 = b | undefined;
+var rj7 = 0 | undefined;
+var rj8 = E.b | undefined;
+
+// operator *
+var rk1 = undefined ** a;
+var rk2 = undefined ** b;
+var rk3 = undefined ** 1;
+var rk4 = undefined ** E.a;
+var rk5 = a ** undefined;
+var rk6 = b ** undefined;
+var rk7 = 0 ** undefined;
+var rk8 = E.b ** undefined;