public void WriteCastOp(CastOp s, ExpressionUsage u)
{
switch (s.CastType)
{
default:
WriteCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Up:
WriteUpCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Down:
WriteDownCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Box:
WriteBox(s.Source, s.ReturnType, s.Operand, false, u);
break;
case CastType.Unbox:
WriteUnbox(s.Source, s.ReturnType, s.Operand, u);
break;
}
}
public static bool TryTransformEnumHasFlagToIntOps(this CallMethod s, Log log, ref Expression result)
{
// Enum.HasFlag() -> (((int)a & (int)b) == (int)b)
if (s.Method.DeclaringType is EnumType && s.Method.UnoName == "HasFlag" && s.Arguments.Length == 1)
{
var bt = s.Method.DeclaringType.Base;
foreach (var o in bt.Operators)
{
if (o.UnoName == "op_BitwiseAnd")
{
var a = new CastOp(s.Source, bt, s.Object.ActualValue);
var b = new CastOp(s.Source, bt, s.Arguments[0]);
foreach (var p in bt.Operators)
{
if (p.UnoName == "op_Equality")
{
result = new CallBinOp(s.Source, p, new CallBinOp(s.Source, o, a, b), b);
return(true);
}
}
log.Error(s.Source, ErrorCode.I0069, "'" + bt + ".op_Equality(" + bt + "," + bt + ")' was not found");
return(false);
}
}
log.Error(s.Source, ErrorCode.I0069, "'" + bt + ".op_BitwiseAnd(" + bt + "," + bt + ")' was not found");
}
return(false);
}
public static bool TryTransformEnumUnOpToIntUnOp(this CallUnOp s, Log log, ref Expression result)
{
// Enum.UnOps -> Int.UnOps
if (s.Operator.DeclaringType is EnumType)
{
var bt = s.Operator.DeclaringType.Base;
foreach (var o in bt.Operators)
{
if (o.UnoName == s.Operator.UnoName)
{
result = new CallUnOp(s.Source, o,
new CastOp(s.Source, bt, s.Operand));
if (s.ReturnType == s.Operator.DeclaringType)
{
result = new CastOp(s.Source, s.Operator.DeclaringType, result);
}
return(true);
}
}
log.Error(s.Source, ErrorCode.I0071, "'" + bt + "." + s.Operator.UnoName + "(" + bt + ")' was not found");
}
return(false);
}
public static bool TryTransformDelegateBinOp(this CallBinOp s, ILFactory ilf, ref Expression result)
{
DataType dt = s.Operator.DeclaringType;
if (dt is DelegateType)
{
if (s.Operator.Symbol == "+")
{
result = new CastOp(s.Source, dt, ilf.CallMethod(s.Source, dt, "Combine", s.Left, s.Right));
return(true);
}
if (s.Operator.Symbol == "-")
{
result = new CastOp(s.Source, dt, ilf.CallMethod(s.Source, dt, "Remove", s.Left, s.Right));
return(true);
}
}
return(false);
}
private Node RewriteAsCastToUnderlyingType(md.PrimitiveType underlyingType, CastOp op, Node n)
{
// if type of the argument and the underlying type match we can strip the Cast entirely
if (underlyingType.PrimitiveTypeKind
== ((md.PrimitiveType)n.Child0.Op.Type.EdmType).PrimitiveTypeKind)
{
return n.Child0;
}
else
{
return m_command.CreateNode(m_command.CreateCastOp(md.TypeUsage.Create(underlyingType, op.Type.Facets)), n.Child0);
}
}
public override Node Visit(CastOp op, Node n)
{
// Visit children first to get rid of all the nominal types (including enums) in the subtree.
VisitChildren(n);
// if casting to enum (e.g. (Color)3) - get rid of the cast if underlying type of the enum is the same
// as the type of the cast argument. If they are not the same rewrite the cast so that the argument
// is casted to the underlying enum type.
if (md.TypeSemantics.IsEnumerationType(op.Type))
{
// We visited subtree so the result type of the cast argument should be now primitive even if it originally was not (e.g. enum).
PlanCompiler.Assert(md.TypeSemantics.IsPrimitiveType(n.Child0.Op.Type), "Primitive type expected.");
var underlyingType = md.Helper.GetUnderlyingEdmTypeForEnumType(op.Type.EdmType);
return RewriteAsCastToUnderlyingType(underlyingType, op, n);
}
if (md.TypeSemantics.IsSpatialType(op.Type))
{
// We visited subtree so the result type of the cast argument should now be a union spatial type even if it was originally strong).
PlanCompiler.Assert(
md.TypeSemantics.IsPrimitiveType(n.Child0.Op.Type, md.PrimitiveTypeKind.Geography)
|| md.TypeSemantics.IsPrimitiveType(n.Child0.Op.Type, md.PrimitiveTypeKind.Geometry), "Union spatial type expected.");
var underlyingType = md.Helper.GetSpatialNormalizedPrimitiveType(op.Type.EdmType);
return RewriteAsCastToUnderlyingType(underlyingType, op, n);
}
// children visited so it's OK just to return the node
return n;
}
/// <summary>
/// Copies a CastOp
/// </summary>
/// <param name="op">The Op to Copy</param>
/// <param name="n">The Node that references the Op</param>
/// <returns>A copy of the original Node that references a copy of the original Op</returns>
public override Node Visit(CastOp op, Node n)
{
return(CopyDefault(m_destCmd.CreateCastOp(op.Type), n));
}
/// <summary>
/// Visitor pattern method for CastOp
/// </summary>
/// <param name="op"> The CastOp being visited </param>
/// <param name="n"> The Node that references the Op </param>
public virtual void Visit(CastOp op, Node n)
{
VisitScalarOpDefault(op, n);
}
// <summary>
// Copies a CastOp
// </summary>
// <param name="op"> The Op to Copy </param>
// <param name="n"> The Node that references the Op </param>
// <returns> A copy of the original Node that references a copy of the original Op </returns>
public override Node Visit(CastOp op, Node n)
{
return CopyDefault(m_destCmd.CreateCastOp(op.Type), n);
}
