public override INamespaceSet BinaryOperation(Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
switch (operation) {
case JOperator.GreaterThan:
case JOperator.LessThan:
case JOperator.LessThanOrEqual:
case JOperator.GreaterThanOrEqual:
case JOperator.Equal:
case JOperator.NotEqual:
case JOperator.Is:
case JOperator.IsNot:
return ProjectState._boolType.Instance;
case JOperator.TrueDivide:
case JOperator.Add:
case JOperator.Subtract:
case JOperator.Multiply:
case JOperator.Divide:
case JOperator.Mod:
case JOperator.BitwiseAnd:
case JOperator.BitwiseOr:
case JOperator.Xor:
case JOperator.LeftShift:
case JOperator.RightShift:
case JOperator.Power:
case JOperator.FloorDivide:
return ConstantInfo.NumericOp(node, this, unit, operation, rhs) ?? base.BinaryOperation(node, unit, operation, rhs);
}
return base.BinaryOperation(node, unit, operation, rhs);
}
public static INamespaceSet BinaryOperation(this INamespaceSet self, Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
var res = NamespaceSet.Empty;
foreach (var ns in self) {
res = res.Union(ns.BinaryOperation(node, unit, operation, rhs));
}
return res;
}
public BinaryExpression(JOperator op, Expression left, Expression right)
{
Contract.Assert(left != null);
Contract.Assert(right != null);
if (op == JOperator.None) throw new ArgumentException("bad operator");
_op = op;
_left = left;
_right = right;
StartIndex = left.StartIndex;
EndIndex = right.EndIndex;
}
public override INamespaceSet BinaryOperation(Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
switch (operation) {
case JOperator.Multiply:
INamespaceSet res = NamespaceSet.Empty;
foreach (var type in rhs) {
var typeId = type.TypeId;
if (typeId == BuiltinTypeId.Int || typeId == BuiltinTypeId.Long) {
res = res.Union(this);
} else {
var partialRes = type.ReverseBinaryOperation(node, unit, operation, SelfSet);
if (partialRes != null) {
res = res.Union(partialRes);
}
}
}
return res;
}
return base.BinaryOperation(node, unit, operation, rhs);
}
public override INamespaceSet UnaryOperation(Node node, AnalysisUnit unit, JOperator operation)
{
var res = NamespaceSet.Empty;
foreach (var member in _members) {
res = res.Union(member.UnaryOperation(node, unit, operation));
}
return res;
}
public override INamespaceSet ReverseBinaryOperation(Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
string op = null;
switch (operation) {
case JOperator.Multiply: op = "__rmul__"; break;
case JOperator.Add: op = "__radd__"; break;
case JOperator.Subtract: op = "__rsub__"; break;
case JOperator.Xor: op = "__rxor__"; break;
case JOperator.BitwiseAnd: op = "__rand__"; break;
case JOperator.BitwiseOr: op = "__ror__"; break;
case JOperator.Divide: op = "__rdiv__"; break;
case JOperator.FloorDivide: op = "__rfloordiv__"; break;
case JOperator.LeftShift: op = "__rlshift__"; break;
case JOperator.Mod: op = "__rmod__"; break;
case JOperator.Power: op = "__rpow__"; break;
case JOperator.RightShift: op = "__rrshift__"; break;
case JOperator.TrueDivide: op = "__rtruediv__"; break;
}
if (op != null) {
var invokeMem = GetMember(node, unit, op);
if (invokeMem.Count > 0) {
// call __r*__ method
return invokeMem.Call(node, unit, new[] { rhs }, ExpressionEvaluator.EmptyNames);
}
}
return base.ReverseBinaryOperation(node, unit, operation, rhs);
}
internal static INamespaceSet NumericOp(Node node, BuiltinInstanceInfo lhs, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
var res = NamespaceSet.Empty;
var lhsType = lhs.TypeId;
foreach(var ns in rhs) {
var rhsType = ns.TypeId;
// First handle string operations
if (lhsType == BuiltinTypeId.Bytes || lhsType == BuiltinTypeId.Str) {
if (operation == JOperator.Mod) {
res = res.Union(lhs.ClassInfo.Instance);
} else if (operation == JOperator.Add &&
(rhsType == BuiltinTypeId.Bytes || rhsType == BuiltinTypeId.Str)) {
res = res.Union(lhs.ClassInfo.Instance);
} else if (operation == JOperator.Multiply &&
(rhsType == BuiltinTypeId.Int || rhsType == BuiltinTypeId.Long)) {
res = res.Union(lhs.ClassInfo.Instance);
}
continue;
} else if (operation == JOperator.Multiply &&
(lhsType == BuiltinTypeId.Int || lhsType == BuiltinTypeId.Long)) {
if (rhsType == BuiltinTypeId.Bytes) {
res = res.Union(unit.ProjectState._bytesType.Instance);
continue;
} else if (rhsType == BuiltinTypeId.Str) {
res = res.Union(unit.ProjectState._unicodeType.Instance);
continue;
} else if (rhsType == BuiltinTypeId.Tuple) {
res = res.Union(unit.ProjectState._tupleType.Instance);
continue;
} else if (rhsType == BuiltinTypeId.List) {
res = res.Union(unit.ProjectState._listType.Instance);
continue;
}
}
// These specializations change rhsType before type promotion
// rules are applied.
if ((operation == JOperator.TrueDivide ||
(operation == JOperator.Divide && unit.ProjectState.LanguageVersion.Is7x())) &&
(lhsType == BuiltinTypeId.Int || lhsType == BuiltinTypeId.Long) &&
(rhsType == BuiltinTypeId.Int || rhsType == BuiltinTypeId.Long)) {
rhsType = BuiltinTypeId.Float;
}
// Type promotion rules are applied
if (lhsType == BuiltinTypeId.Unknown || lhsType > BuiltinTypeId.Complex ||
rhsType == BuiltinTypeId.Unknown || rhsType > BuiltinTypeId.Complex) {
// Non-numeric types require the reverse operation
res = res.Union(ns.ReverseBinaryOperation(node, unit, operation, lhs));
} else if (lhsType == BuiltinTypeId.Complex || rhsType == BuiltinTypeId.Complex) {
res = res.Union(unit.ProjectState._complexType.Instance);
} else if (lhsType == BuiltinTypeId.Float || rhsType == BuiltinTypeId.Float) {
res = res.Union(unit.ProjectState._floatType.Instance);
} else if (lhsType == BuiltinTypeId.Long || rhsType == BuiltinTypeId.Long) {
res = res.Union(unit.ProjectState._longType.Instance);
} else {
res = res.Union(unit.ProjectState._intType.Instance);
}
}
return res.Count > 0 ? res : null;
}
public override INamespaceSet UnaryOperation(Node node, AnalysisUnit unit, JOperator operation)
{
return _builtinInfo.UnaryOperation(node, unit, operation);
}
public override INamespaceSet BinaryOperation(Node node, AnalysisUnit unit, JOperator operation, INamespaceSet rhs)
{
return NumericOp(node, this, unit, operation, rhs) ?? _builtinInfo.BinaryOperation(node, unit, operation, rhs);
}
public AugmentedAssignStatement(JOperator op, Expression left, Expression right)
{
_op = op;
_left = left;
_right = right;
}
public UnaryExpression(JOperator op, Expression expression)
{
_op = op;
_expression = expression;
EndIndex = expression.EndIndex;
}
