protected void VisitIndexerExpression()
{
this.isRefArg = this.Emitter.IsRefArg;
this.Emitter.IsRefArg = false;
IndexerExpression indexerExpression = this.IndexerExpression;
int pos = this.Emitter.Output.Length;
var resolveResult = this.Emitter.Resolver.ResolveNode(indexerExpression, this.Emitter);
var memberResolveResult = resolveResult as MemberResolveResult;
var arrayAccess = resolveResult as ArrayAccessResolveResult;
if (arrayAccess != null && arrayAccess.Indexes.Count > 1)
{
this.EmitMultiDimArrayAccess(indexerExpression);
Helpers.CheckValueTypeClone(resolveResult, indexerExpression, this, pos);
return;
}
var isIgnore = true;
var isAccessorsIndexer = false;
IProperty member = null;
IndexerAccessor current = null;
if (memberResolveResult != null)
{
var resolvedMember = memberResolveResult.Member;
isIgnore = this.Emitter.Validator.IsIgnoreType(resolvedMember.DeclaringTypeDefinition);
isAccessorsIndexer = this.Emitter.Validator.IsAccessorsIndexer(resolvedMember);
var property = resolvedMember as IProperty;
if (property != null)
{
member = property;
current = this.GetIndexerAccessor(member, this.Emitter.IsAssignment);
}
}
if (current != null && current.InlineAttr != null)
{
this.EmitInlineIndexer(indexerExpression, current);
}
else if (!(isIgnore || (current != null && current.IgnoreAccessor)) || isAccessorsIndexer)
{
this.EmitAccessorIndexer(indexerExpression, memberResolveResult, member);
}
else
{
this.EmitSingleDimArrayIndexer(indexerExpression);
}
Helpers.CheckValueTypeClone(resolveResult, indexerExpression, this, pos);
}
private static void CheckNumericConversion(ConversionBlock block, Expression expression, ResolveResult rr, IType expectedType, Conversion conversion)
{
var fromType = rr.Type;
var toType = expectedType;
if (fromType.Kind == TypeKind.Enum)
{
fromType = fromType.GetDefinition().EnumUnderlyingType;
}
if (toType.Kind == TypeKind.Enum)
{
toType = toType.GetDefinition().EnumUnderlyingType;
}
bool isArrayIndex = false;
if (Helpers.Is64Type(toType, block.Emitter.Resolver) && expression.Parent is IndexerExpression &&
((IndexerExpression)expression.Parent).Arguments.Contains(expression))
{
var memberResolveResult = rr as MemberResolveResult;
var isIgnore = true;
var isAccessorsIndexer = false;
IProperty member = null;
IndexerAccessor current = null;
if (memberResolveResult == null)
{
memberResolveResult = block.Emitter.Resolver.ResolveNode(expression.Parent, block.Emitter) as MemberResolveResult;
}
if (memberResolveResult != null)
{
var resolvedMember = memberResolveResult.Member;
isIgnore = block.Emitter.Validator.IsExternalType(resolvedMember.DeclaringTypeDefinition);
isAccessorsIndexer = block.Emitter.Validator.IsAccessorsIndexer(resolvedMember);
var property = resolvedMember as IProperty;
if (property != null)
{
member = property;
current = IndexerBlock.GetIndexerAccessor(block.Emitter, member, block.Emitter.IsAssignment);
}
}
if (!(current != null && current.InlineAttr != null) && !(!(isIgnore || (current != null && current.IgnoreAccessor)) || isAccessorsIndexer))
{
block.Write(JS.Types.System.Int64.TONUMBER);
block.Write("(");
isArrayIndex = true;
}
}
if ((conversion.IsNumericConversion || conversion.IsEnumerationConversion) && conversion.IsExplicit)
{
if (!(expression.Parent is ArrayInitializerExpression) &&
Helpers.Is64Type(fromType, block.Emitter.Resolver) &&
Helpers.IsFloatType(toType, block.Emitter.Resolver) &&
!Helpers.IsDecimalType(toType, block.Emitter.Resolver))
{
var be = expression.Parent as BinaryOperatorExpression;
if (be == null || be.Operator != BinaryOperatorType.Divide || be.Left != expression)
{
block.Write(JS.Types.System.Int64.TONUMBER);
if (!(expression is CastExpression && ((CastExpression)expression).Expression is ParenthesizedExpression))
{
block.Write("(");
block.AfterOutput += ")";
}
}
}
else if (Helpers.IsDecimalType(toType, block.Emitter.Resolver) && !Helpers.IsDecimalType(fromType, block.Emitter.Resolver))
{
block.Write(JS.Types.SYSTEM_DECIMAL + "(");
block.AfterOutput += ", null, " + BridgeTypes.ToJsName(fromType, block.Emitter) + ")";
}
else if (Helpers.IsDecimalType(fromType, block.Emitter.Resolver))
{
ClipDecimal(expression, block, toType);
}
else if (Helpers.Is64Type(fromType, block.Emitter.Resolver))
{
CheckLong(block, expression, toType, fromType, IsInCheckedContext(block.Emitter, expression));
}
else if (Helpers.IsFloatType(fromType, block.Emitter.Resolver) && Helpers.IsIntegerType(toType, block.Emitter.Resolver))
{
FloatToInt(block, expression, fromType, toType, IsInCheckedContext(block.Emitter, expression));
}
else if (NeedsNarrowingNumericConversion(fromType, toType))
{
if (IsInCheckedContext(block.Emitter, expression))
{
CheckInteger(block, expression, toType);
}
else
{
ClipInteger(block, expression, toType, true);
}
}
}
else if (conversion.IsNumericConversion && conversion.IsImplicit && !(expression.Parent is ArrayInitializerExpression) &&
Helpers.Is64Type(fromType, block.Emitter.Resolver) &&
Helpers.IsFloatType(toType, block.Emitter.Resolver) &&
!Helpers.IsDecimalType(toType, block.Emitter.Resolver))
{
var be = expression.Parent as BinaryOperatorExpression;
if (be == null || be.Operator != BinaryOperatorType.Divide || be.Left != expression)
{
block.Write(JS.Types.System.Int64.TONUMBER);
if (!(expression is CastExpression && ((CastExpression)expression).Expression is ParenthesizedExpression))
{
block.Write("(");
block.AfterOutput += ")";
}
}
}
else if (((!Helpers.Is64Type(toType, block.Emitter.Resolver) && Helpers.IsIntegerType(toType, block.Emitter.Resolver)) ||
(rr is OperatorResolveResult && !Helpers.Is64Type(fromType, block.Emitter.Resolver) && Helpers.IsIntegerType(fromType, block.Emitter.Resolver))) &&
(expression is BinaryOperatorExpression || expression is UnaryOperatorExpression || expression.Parent is AssignmentExpression) &&
IsInCheckedContext(block.Emitter, expression))
{
var needCheck = false;
var be = expression as BinaryOperatorExpression;
bool isBitwiseOperator = be != null && (be.Operator == BinaryOperatorType.ShiftLeft || be.Operator == BinaryOperatorType.ShiftRight || be.Operator == BinaryOperatorType.BitwiseAnd || be.Operator == BinaryOperatorType.BitwiseOr || be.Operator == BinaryOperatorType.ExclusiveOr);
if ((Helpers.IsKnownType(KnownTypeCode.Int32, toType, block.Emitter.Resolver) && isBitwiseOperator) || (Helpers.IsKnownType(KnownTypeCode.UInt32, toType, block.Emitter.Resolver) && be != null && be.Operator == BinaryOperatorType.ShiftRight))
{
// Don't need to check even in checked context and don't need to clip
}
else if (be != null && (be.Operator == BinaryOperatorType.Add ||
be.Operator == BinaryOperatorType.Divide ||
be.Operator == BinaryOperatorType.Multiply ||
isBitwiseOperator ||
be.Operator == BinaryOperatorType.Subtract))
{
if (isBitwiseOperator)
{
ClipInteger(block, expression, toType, false);
}
else
{
needCheck = true;
}
}
else
{
var ue = expression as UnaryOperatorExpression;
if (ue != null && (ue.Operator == UnaryOperatorType.Minus ||
ue.Operator == UnaryOperatorType.Increment ||
ue.Operator == UnaryOperatorType.Decrement ||
ue.Operator == UnaryOperatorType.PostIncrement ||
ue.Operator == UnaryOperatorType.PostDecrement))
{
needCheck = true;
}
else
{
var ae = expression.Parent as AssignmentExpression;
isBitwiseOperator = ae != null && (ae.Operator == AssignmentOperatorType.ShiftRight || ae.Operator == AssignmentOperatorType.ShiftLeft || ae.Operator == AssignmentOperatorType.BitwiseAnd || ae.Operator == AssignmentOperatorType.BitwiseOr || ae.Operator == AssignmentOperatorType.ExclusiveOr);
if ((isBitwiseOperator && Helpers.IsKnownType(KnownTypeCode.Int32, toType, block.Emitter.Resolver)) ||
(ae != null && ae.Operator == AssignmentOperatorType.ShiftRight && Helpers.IsKnownType(KnownTypeCode.UInt32, toType, block.Emitter.Resolver)))
{
// Don't need to check even in checked context and don't need to clip
}
else if (ae != null && (isBitwiseOperator || ae.Operator == AssignmentOperatorType.Add ||
ae.Operator == AssignmentOperatorType.Divide ||
ae.Operator == AssignmentOperatorType.Multiply ||
ae.Operator == AssignmentOperatorType.Subtract))
{
if (isBitwiseOperator)
{
ClipInteger(block, expression, toType, false);
}
else
{
needCheck = true;
}
}
}
}
if (!Helpers.IsIntegerType(toType, block.Emitter.Resolver))
{
if (rr is OperatorResolveResult)
{
toType = fromType;
}
}
if (needCheck)
{
CheckInteger(block, expression, toType);
}
}
else if (((!Helpers.Is64Type(toType, block.Emitter.Resolver) && Helpers.IsIntegerType(toType, block.Emitter.Resolver)) ||
(rr is OperatorResolveResult && !Helpers.Is64Type(fromType, block.Emitter.Resolver) && Helpers.IsIntegerType(fromType, block.Emitter.Resolver))) &&
(expression is BinaryOperatorExpression || expression is UnaryOperatorExpression || expression.Parent is AssignmentExpression) &&
IsInUncheckedContext(block.Emitter, expression))
{
if (ConversionBlock.IsLongConversion(block, expression, rr, toType, conversion) || rr is ConstantResolveResult)
{
return;
}
if (!Helpers.IsIntegerType(toType, block.Emitter.Resolver))
{
if (rr is OperatorResolveResult)
{
toType = fromType;
}
}
var needCheck = false;
var be = expression as BinaryOperatorExpression;
bool isBitwiseOperator = be != null && (be.Operator == BinaryOperatorType.ShiftLeft || be.Operator == BinaryOperatorType.ShiftRight || be.Operator == BinaryOperatorType.BitwiseAnd || be.Operator == BinaryOperatorType.BitwiseOr || be.Operator == BinaryOperatorType.ExclusiveOr);
if ((Helpers.IsKnownType(KnownTypeCode.Int32, toType, block.Emitter.Resolver) && isBitwiseOperator) || (Helpers.IsKnownType(KnownTypeCode.UInt32, toType, block.Emitter.Resolver) && be != null && be.Operator == BinaryOperatorType.ShiftRight))
{
// Don't need to check even in checked context and don't need to clip
}
else if (be != null && !(be.Left is PrimitiveExpression && be.Right is PrimitiveExpression) && (be.Operator == BinaryOperatorType.Add ||
be.Operator == BinaryOperatorType.Divide ||
be.Operator == BinaryOperatorType.Multiply ||
isBitwiseOperator ||
be.Operator == BinaryOperatorType.Subtract))
{
needCheck = true;
}
else
{
var ue = expression as UnaryOperatorExpression;
if (ue != null && !(ue.Expression is PrimitiveExpression) && (ue.Operator == UnaryOperatorType.Minus ||
ue.Operator == UnaryOperatorType.Increment ||
ue.Operator == UnaryOperatorType.Decrement ||
ue.Operator == UnaryOperatorType.PostIncrement ||
ue.Operator == UnaryOperatorType.PostDecrement))
{
needCheck = true;
}
else
{
var ae = expression.Parent as AssignmentExpression;
isBitwiseOperator = ae != null && (ae.Operator == AssignmentOperatorType.ShiftRight || ae.Operator == AssignmentOperatorType.ShiftLeft || ae.Operator == AssignmentOperatorType.BitwiseAnd || ae.Operator == AssignmentOperatorType.BitwiseOr || ae.Operator == AssignmentOperatorType.ExclusiveOr);
if ((isBitwiseOperator && Helpers.IsKnownType(KnownTypeCode.Int32, toType, block.Emitter.Resolver)) ||
(ae != null && ae.Operator == AssignmentOperatorType.ShiftRight && Helpers.IsKnownType(KnownTypeCode.UInt32, toType, block.Emitter.Resolver)))
{
// Don't need to check even in checked context and don't need to clip
}
else if (ae != null && (isBitwiseOperator || ae.Operator == AssignmentOperatorType.Add ||
ae.Operator == AssignmentOperatorType.Divide ||
ae.Operator == AssignmentOperatorType.Multiply ||
ae.Operator == AssignmentOperatorType.Subtract))
{
needCheck = true;
}
}
}
if (needCheck)
{
ClipInteger(block, expression, toType, false);
}
}
if (isArrayIndex)
{
block.AfterOutput += ")";
}
}
protected virtual void EmitInlineIndexer(IndexerExpression indexerExpression, IndexerAccessor current)
{
var oldIsAssignment = this.Emitter.IsAssignment;
var oldUnary = this.Emitter.IsUnaryAccessor;
var inlineCode = current.InlineCode;
if (!(current.InlineCode != null && current.InlineCode.Contains("{this}")) && current.InlineAttr != null)
{
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
}
if (inlineCode != null && inlineCode.Contains("{this}"))
{
this.Write("");
var oldBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
inlineCode = inlineCode.Replace("{this}", this.Emitter.Output.ToString());
this.Emitter.Output = oldBuilder;
this.PushWriter(inlineCode);
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
return;
}
if (inlineCode != null)
{
this.WriteDot();
this.PushWriter(inlineCode);
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
}
}
protected virtual void EmitInlineIndexer(IndexerExpression indexerExpression, IndexerAccessor current)
{
var oldIsAssignment = this.Emitter.IsAssignment;
var oldUnary = this.Emitter.IsUnaryAccessor;
var inlineCode = current.InlineCode;
bool hasThis = inlineCode != null && inlineCode.Contains("{this}");
if (inlineCode != null && inlineCode.StartsWith("<self>"))
{
hasThis = true;
inlineCode = inlineCode.Substring(6);
}
if (!hasThis && current.InlineAttr != null)
{
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
}
if (hasThis)
{
this.Write("");
var oldBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
int thisIndex = inlineCode.IndexOf("{this}");
var thisArg = this.Emitter.Output.ToString();
inlineCode = inlineCode.Replace("{this}", thisArg);
this.Emitter.Output = oldBuilder;
int[] range = null;
if (thisIndex > -1)
{
range = new[] { thisIndex, thisIndex + thisArg.Length };
}
this.PushWriter(inlineCode, null, thisArg, range);
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
return;
}
if (inlineCode != null)
{
this.WriteDot();
this.PushWriter(inlineCode);
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
}
}
