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(); } } }