Implement experimental exponentiation operator

src/compiler/typer.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 332 matching lines @@
   static Type* ToNumber(Type*, Typer*);
   static Type* ToString(Type*, Typer*);
   static Type* NumberToInt32(Type*, Typer*);
   static Type* NumberToUint32(Type*, Typer*);
 
   static Type* JSAddRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSSubtractRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSMultiplyRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSDivideRanger(Type::RangeType*, Type::RangeType*, Typer*);
   static Type* JSModulusRanger(Type::RangeType*, Type::RangeType*, Typer*);
+  static Type* JSExponentiateRanger(Type::RangeType*, Type::RangeType*, Typer*);
 
   static ComparisonOutcome JSCompareTyper(Type*, Type*, Typer*);
 
 #define DECLARE_METHOD(x) static Type* x##Typer(Type*, Type*, Typer*);
   JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
 
   static Type* JSUnaryNotTyper(Type*, Typer*);
   static Type* JSLoadPropertyTyper(Type*, Type*, Typer*);
   static Type* JSCallFunctionTyper(Type*, Typer*);
@@ skipping 853 matching lines @@
 
   lhs = Rangify(lhs, t);
   rhs = Rangify(rhs, t);
   if (lhs->IsRange() && rhs->IsRange()) {
     return JSModulusRanger(lhs->AsRange(), rhs->AsRange(), t);
   }
   return Type::OrderedNumber();
 }
 
 
+Type* Typer::Visitor::JSExponentiateRanger(Type::RangeType* lhs,
+                                           Type::RangeType* rhs, Typer* t) {
+  return Type::Range(-V8_INFINITY, +V8_INFINITY, t->zone());

[Michael Starzinger, 2015/02/24 14:09:03]

This is a pretty broad range. :)

[caitp (gmail), 2015/02/24 14:56:12]

I have some ideas for how to make it a bit more narrow, but it's still going to
be [-ε...-1], [ε...1], [-ε...-Infinity], [ε...Infinity] --- broad range seemed
easiest to get working quickly.

+}
+
+
+Type* Typer::Visitor::JSExponentiateTyper(Type* lhs, Type* rhs, Typer* t) {
+  if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();

[Michael Starzinger, 2015/02/24 14:09:03]

Isn't the exponentiation supposed to perform an implicit ToNumber conversion (or
something similar)? This doesn't seem to be reflected here.

[caitp (gmail), 2015/02/24 14:56:12]

I might be misunderstanding what the typer is doing. I think I'm determining a
type for the node output, based on the input nodes? Is there a way to tell the
input nodes they need to be converted to numbers here?

+  return Type::Number();
+}
+
+
 // JS unary operators.
 
 
 Type* Typer::Visitor::JSUnaryNotTyper(Type* type, Typer* t) {
   return Invert(ToBoolean(type, t), t);
 }
 
 
 Bounds Typer::Visitor::TypeJSUnaryNot(Node* node) {
   return TypeUnaryOp(node, JSUnaryNotTyper);
@@ skipping 333 matching lines @@
 Bounds Typer::Visitor::TypeNumberDivide(Node* node) {
   return Bounds(Type::None(zone()), Type::Number(zone()));
 }
 
 
 Bounds Typer::Visitor::TypeNumberModulus(Node* node) {
   return Bounds(Type::None(zone()), Type::Number(zone()));
 }
 
 
+Bounds Typer::Visitor::TypeNumberExponentiate(Node* node) {
+  return Bounds(Type::None(zone()), Type::Number(zone()));
+}
+
+
 Bounds Typer::Visitor::TypeNumberToInt32(Node* node) {
   return TypeUnaryOp(node, NumberToInt32);
 }
 
 
 Bounds Typer::Visitor::TypeNumberToUint32(Node* node) {
   return TypeUnaryOp(node, NumberToUint32);
 }
 
 
@@ skipping 595 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8