mirror of https://github.com/icsharpcode/ILSpy.git
Siegfried Pammer
6 years ago
committed by
GitHub
23 changed files with 1265 additions and 81 deletions
@ -0,0 +1,281 @@ |
|||||||
|
// Copyright (c) 2020 Daniel Grunwald
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||||
|
// software and associated documentation files (the "Software"), to deal in the Software
|
||||||
|
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||||
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||||
|
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all copies or
|
||||||
|
// substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||||
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||||
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||||
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||||
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
// DEALINGS IN THE SOFTWARE.
|
||||||
|
|
||||||
|
using System; |
||||||
|
using System.Collections.Generic; |
||||||
|
|
||||||
|
namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty |
||||||
|
{ |
||||||
|
internal class CustomList |
||||||
|
{ |
||||||
|
public int Count => 0; |
||||||
|
public int this[int index] => 0; |
||||||
|
|
||||||
|
public CustomList Slice(int start, int length) |
||||||
|
{ |
||||||
|
return this; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
internal class CustomList2 |
||||||
|
{ |
||||||
|
public int Count => 0; |
||||||
|
public int this[int index] => 0; |
||||||
|
public int this[Index index] => 0; |
||||||
|
public CustomList2 this[Range range] => this; |
||||||
|
|
||||||
|
public CustomList2 Slice(int start, int length) |
||||||
|
{ |
||||||
|
return this; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
internal class IndexRangeTest |
||||||
|
{ |
||||||
|
public static int[] GetArray() |
||||||
|
{ |
||||||
|
throw null; |
||||||
|
} |
||||||
|
public static List<int> GetList() |
||||||
|
{ |
||||||
|
throw null; |
||||||
|
} |
||||||
|
public static Span<int> GetSpan() |
||||||
|
{ |
||||||
|
throw null; |
||||||
|
} |
||||||
|
public static string GetString() |
||||||
|
{ |
||||||
|
throw null; |
||||||
|
} |
||||||
|
public static Index GetIndex(int i = 0) |
||||||
|
{ |
||||||
|
return i; |
||||||
|
} |
||||||
|
public static Range GetRange(int i = 0) |
||||||
|
{ |
||||||
|
return i..^i; |
||||||
|
} |
||||||
|
public static int GetInt(int i = 0) |
||||||
|
{ |
||||||
|
return i; |
||||||
|
} |
||||||
|
public static Range[] SeveralRanges() |
||||||
|
{ |
||||||
|
// Some of these are semantically identical, but we can still distinguish them in the IL code:
|
||||||
|
return new Range[14] { |
||||||
|
.., |
||||||
|
0.., |
||||||
|
^0.., |
||||||
|
GetInt(1).., |
||||||
|
^GetInt(2).., |
||||||
|
..0, |
||||||
|
..^0, |
||||||
|
..GetInt(3), |
||||||
|
..^GetInt(4), |
||||||
|
0..^0, |
||||||
|
^0..0, |
||||||
|
0..0, |
||||||
|
GetInt(5)..GetInt(6), |
||||||
|
0..(GetInt(7) + GetInt(8)) |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseIndex() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetIndex()]); |
||||||
|
Console.WriteLine(GetList()[GetIndex()]); |
||||||
|
Console.WriteLine(GetSpan()[GetIndex()]); |
||||||
|
Console.WriteLine(GetString()[GetIndex()]); |
||||||
|
Console.WriteLine(new CustomList()[GetIndex()]); |
||||||
|
Console.WriteLine(new CustomList2()[GetIndex()]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseIndexFromEnd() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[^GetInt()]); |
||||||
|
Console.WriteLine(GetList()[^GetInt()]); |
||||||
|
Console.WriteLine(GetSpan()[^GetInt()]); |
||||||
|
Console.WriteLine(GetString()[^GetInt()]); |
||||||
|
Console.WriteLine(new CustomList()[^GetInt()]); |
||||||
|
Console.WriteLine(new CustomList2()[^GetInt()]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseIndexForWrite() |
||||||
|
{ |
||||||
|
GetArray()[GetIndex()] = GetInt(); |
||||||
|
GetList()[GetIndex()] = GetInt(); |
||||||
|
GetSpan()[GetIndex()] = GetInt(); |
||||||
|
} |
||||||
|
|
||||||
|
private static void UseRef(ref int i) |
||||||
|
{ |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseIndexForRef() |
||||||
|
{ |
||||||
|
UseRef(ref GetArray()[GetIndex()]); |
||||||
|
UseRef(ref GetArray()[^GetInt()]); |
||||||
|
UseRef(ref GetSpan()[GetIndex()]); |
||||||
|
UseRef(ref GetSpan()[^GetInt()]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseRange() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetRange()]); |
||||||
|
//Console.WriteLine(GetList()[GetRange()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[GetRange()].ToString()); |
||||||
|
Console.WriteLine(GetString()[GetRange()]); |
||||||
|
Console.WriteLine(new CustomList()[GetRange()]); |
||||||
|
Console.WriteLine(new CustomList2()[GetRange()]); |
||||||
|
} |
||||||
|
public static void UseNewRangeFromIndex() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetIndex(1)..GetIndex(2)]); |
||||||
|
//Console.WriteLine(GetList()[GetIndex(1)..GetIndex(2)]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[GetIndex(1)..GetIndex(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[GetIndex(1)..GetIndex(2)]); |
||||||
|
Console.WriteLine(new CustomList()[GetIndex(1)..GetIndex(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[GetIndex(1)..GetIndex(2)]); |
||||||
|
} |
||||||
|
public static void UseNewRangeFromIntegers_BothFromStart() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetInt(1)..GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[GetInt()..GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[GetInt(1)..GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[GetInt(1)..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[GetInt(1)..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[GetInt(1)..GetInt(2)]); |
||||||
|
} |
||||||
|
public static void UseNewRangeFromIntegers_BothFromEnd() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[^GetInt(1)..^GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[^GetInt()..^GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[^GetInt(1)..^GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[^GetInt(1)..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[^GetInt(1)..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[^GetInt(1)..^GetInt(2)]); |
||||||
|
} |
||||||
|
public static void UseNewRangeFromIntegers_FromStartAndEnd() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetInt(1)..^GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[GetInt()..^GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[GetInt(1)..^GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[GetInt(1)..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[GetInt(1)..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[GetInt(1)..^GetInt(2)]); |
||||||
|
} |
||||||
|
public static void UseNewRangeFromIntegers_FromEndAndStart() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[^GetInt(1)..GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[^GetInt()..GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[^GetInt(1)..GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[^GetInt(1)..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[^GetInt(1)..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[^GetInt(1)..GetInt(2)]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseNewRangeFromIntegers_OnlyEndPoint() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[..GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[..GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[..GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[..GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[..GetInt(2)]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseNewRangeFromIntegers_OnlyEndPoint_FromEnd() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[..^GetInt(2)]); |
||||||
|
//Console.WriteLine(GetList()[..^GetInt()]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[..^GetInt(2)].ToString()); |
||||||
|
Console.WriteLine(GetString()[..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList()[..^GetInt(2)]); |
||||||
|
Console.WriteLine(new CustomList2()[..^GetInt(2)]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseNewRangeFromIntegers_OnlyStartPoint() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[GetInt(1)..]); |
||||||
|
//Console.WriteLine(GetList()[GetInt()..]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[GetInt(1)..].ToString()); |
||||||
|
Console.WriteLine(GetString()[GetInt(1)..]); |
||||||
|
Console.WriteLine(new CustomList()[GetInt(1)..]); |
||||||
|
Console.WriteLine(new CustomList2()[GetInt(1)..]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseNewRangeFromIntegers_OnlyStartPoint_FromEnd() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[^GetInt(1)..]); |
||||||
|
//Console.WriteLine(GetList()[^GetInt()..]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[^GetInt(1)..].ToString()); |
||||||
|
Console.WriteLine(GetString()[^GetInt(1)..]); |
||||||
|
Console.WriteLine(new CustomList()[^GetInt(1)..]); |
||||||
|
Console.WriteLine(new CustomList2()[^GetInt(1)..]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseConstantRange() |
||||||
|
{ |
||||||
|
// Fortunately the C# compiler doesn't optimize
|
||||||
|
// "str.Length - 2 - 1" here, so the normal pattern applies.
|
||||||
|
Console.WriteLine(GetString()[1..2]); |
||||||
|
Console.WriteLine(GetString()[1..^1]); |
||||||
|
Console.WriteLine(GetString()[^2..^1]); |
||||||
|
|
||||||
|
Console.WriteLine(GetString()[..1]); |
||||||
|
Console.WriteLine(GetString()[..^1]); |
||||||
|
Console.WriteLine(GetString()[1..]); |
||||||
|
Console.WriteLine(GetString()[^1..]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseWholeRange() |
||||||
|
{ |
||||||
|
Console.WriteLine(GetArray()[..]); |
||||||
|
//Console.WriteLine(GetList()[..]); // fails to compile
|
||||||
|
Console.WriteLine(GetSpan()[..].ToString()); |
||||||
|
Console.WriteLine(GetString()[..]); |
||||||
|
Console.WriteLine(new CustomList()[..]); |
||||||
|
Console.WriteLine(new CustomList2()[..]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseIndexForIntIndexerWhenIndexIndexerIsAvailable() |
||||||
|
{ |
||||||
|
// Same code as the compiler emits for CustomList,
|
||||||
|
// but here we can't translate it back to `customList[GetIndex()]`
|
||||||
|
// because that would call a different overload.
|
||||||
|
CustomList2 customList = new CustomList2(); |
||||||
|
int count = customList.Count; |
||||||
|
int offset = GetIndex().GetOffset(count); |
||||||
|
Console.WriteLine(customList[offset]); |
||||||
|
} |
||||||
|
|
||||||
|
public static void UseSliceWhenRangeIndexerIsAvailable() |
||||||
|
{ |
||||||
|
// Same code as the compiler emits for CustomList,
|
||||||
|
// but here we can't translate it back to `customList[GetIndex()]`
|
||||||
|
// because that would call a different overload.
|
||||||
|
CustomList2 customList = new CustomList2(); |
||||||
|
int count = customList.Count; |
||||||
|
Range range = GetRange(); |
||||||
|
int offset = range.Start.GetOffset(count); |
||||||
|
int length = range.End.GetOffset(count) - offset; |
||||||
|
Console.WriteLine(customList.Slice(offset, length)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,596 @@ |
|||||||
|
// Copyright (c) 2020 Daniel Grunwald
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||||
|
// software and associated documentation files (the "Software"), to deal in the Software
|
||||||
|
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||||
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||||
|
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all copies or
|
||||||
|
// substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||||
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||||
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||||
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||||
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
// DEALINGS IN THE SOFTWARE.
|
||||||
|
|
||||||
|
using System; |
||||||
|
using System.Diagnostics; |
||||||
|
using System.Linq; |
||||||
|
using ICSharpCode.Decompiler.TypeSystem; |
||||||
|
using ICSharpCode.Decompiler.TypeSystem.Implementation; |
||||||
|
|
||||||
|
namespace ICSharpCode.Decompiler.IL.Transforms |
||||||
|
{ |
||||||
|
/// <summary>
|
||||||
|
/// Transform for the C# 8 System.Index / System.Range feature
|
||||||
|
/// </summary>
|
||||||
|
class IndexRangeTransform : IStatementTransform |
||||||
|
{ |
||||||
|
/// <summary>
|
||||||
|
/// Called by expression transforms.
|
||||||
|
/// Handles the `array[System.Index]` cases.
|
||||||
|
/// </summary>
|
||||||
|
public static bool HandleLdElema(LdElema ldelema, ILTransformContext context) |
||||||
|
{ |
||||||
|
if (!context.Settings.Ranges) |
||||||
|
return false; |
||||||
|
if (!ldelema.Array.MatchLdLoc(out ILVariable array)) |
||||||
|
return false; |
||||||
|
if (ldelema.Indices.Count != 1) |
||||||
|
return false; // the index/range feature doesn't support multi-dimensional arrays
|
||||||
|
var index = ldelema.Indices[0]; |
||||||
|
if (index is CallInstruction call && call.Method.Name == "GetOffset" && call.Method.DeclaringType.IsKnownType(KnownTypeCode.Index)) { |
||||||
|
// ldelema T(ldloc array, call GetOffset(..., ldlen.i4(ldloc array)))
|
||||||
|
// -> withsystemindex.ldelema T(ldloc array, ...)
|
||||||
|
if (call.Arguments.Count != 2) |
||||||
|
return false; |
||||||
|
if (!(call.Arguments[1].MatchLdLen(StackType.I4, out var arrayLoad) && arrayLoad.MatchLdLoc(array))) |
||||||
|
return false; |
||||||
|
context.Step("ldelema with System.Index", ldelema); |
||||||
|
foreach (var node in call.Arguments[1].Descendants) |
||||||
|
ldelema.AddILRange(node); |
||||||
|
ldelema.AddILRange(call); |
||||||
|
ldelema.WithSystemIndex = true; |
||||||
|
// The method call had a `ref System.Index` argument for the this pointer, but we want a `System.Index` by-value.
|
||||||
|
ldelema.Indices[0] = new LdObj(call.Arguments[0], call.Method.DeclaringType); |
||||||
|
return true; |
||||||
|
} else if (index is BinaryNumericInstruction bni && bni.Operator == BinaryNumericOperator.Sub && !bni.IsLifted && !bni.CheckForOverflow) { |
||||||
|
// ldelema T(ldloc array, binary.sub.i4(ldlen.i4(ldloc array), ...))
|
||||||
|
// -> withsystemindex.ldelema T(ldloc array, newobj System.Index(..., fromEnd: true))
|
||||||
|
if (!(bni.Left.MatchLdLen(StackType.I4, out var arrayLoad) && arrayLoad.MatchLdLoc(array))) |
||||||
|
return false; |
||||||
|
var indexMethods = new IndexMethods(context.TypeSystem); |
||||||
|
if (!indexMethods.IsValid) |
||||||
|
return false; // don't use System.Index if not supported by the target framework
|
||||||
|
context.Step("ldelema indexed from end", ldelema); |
||||||
|
foreach (var node in bni.Left.Descendants) |
||||||
|
ldelema.AddILRange(node); |
||||||
|
ldelema.AddILRange(bni); |
||||||
|
ldelema.WithSystemIndex = true; |
||||||
|
ldelema.Indices[0] = MakeIndex(IndexKind.FromEnd, bni.Right, indexMethods); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
class IndexMethods |
||||||
|
{ |
||||||
|
public readonly IMethod IndexCtor; |
||||||
|
public readonly IMethod IndexImplicitConv; |
||||||
|
public readonly IMethod RangeCtor; |
||||||
|
public IType IndexType => IndexCtor?.DeclaringType; |
||||||
|
public IType RangeType => RangeCtor?.DeclaringType; |
||||||
|
public bool IsValid => IndexCtor != null && IndexImplicitConv != null && RangeCtor != null; |
||||||
|
|
||||||
|
public readonly IMethod RangeStartAt; |
||||||
|
public readonly IMethod RangeEndAt; |
||||||
|
public readonly IMethod RangeGetAll; |
||||||
|
|
||||||
|
public IndexMethods(ICompilation compilation) |
||||||
|
{ |
||||||
|
var indexType = compilation.FindType(KnownTypeCode.Index); |
||||||
|
foreach (var ctor in indexType.GetConstructors(m => m.Parameters.Count == 2)) { |
||||||
|
if (ctor.Parameters[0].Type.IsKnownType(KnownTypeCode.Int32) |
||||||
|
&& ctor.Parameters[1].Type.IsKnownType(KnownTypeCode.Boolean)) { |
||||||
|
this.IndexCtor = ctor; |
||||||
|
} |
||||||
|
} |
||||||
|
foreach (var op in indexType.GetMethods(m => m.IsOperator && m.Name == "op_Implicit")) { |
||||||
|
if (op.Parameters.Count == 1 && op.Parameters[0].Type.IsKnownType(KnownTypeCode.Int32)) { |
||||||
|
this.IndexImplicitConv = op; |
||||||
|
} |
||||||
|
} |
||||||
|
var rangeType = compilation.FindType(KnownTypeCode.Range); |
||||||
|
foreach (var ctor in rangeType.GetConstructors(m => m.Parameters.Count == 2)) { |
||||||
|
if (ctor.Parameters[0].Type.IsKnownType(KnownTypeCode.Index) |
||||||
|
&& ctor.Parameters[1].Type.IsKnownType(KnownTypeCode.Index)) { |
||||||
|
this.RangeCtor = ctor; |
||||||
|
} |
||||||
|
} |
||||||
|
foreach (var m in rangeType.GetMethods(m => m.Parameters.Count == 1)) { |
||||||
|
if (m.Parameters.Count == 1 && m.Parameters[0].Type.IsKnownType(KnownTypeCode.Index)) { |
||||||
|
if (m.Name == "StartAt") |
||||||
|
this.RangeStartAt = m; |
||||||
|
else if (m.Name == "EndAt") |
||||||
|
this.RangeEndAt = m; |
||||||
|
} |
||||||
|
} |
||||||
|
foreach (var p in rangeType.GetProperties(p => p.IsStatic && p.Name == "All")) { |
||||||
|
this.RangeGetAll = p.Getter; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void IStatementTransform.Run(Block block, int pos, StatementTransformContext context) |
||||||
|
{ |
||||||
|
if (!context.Settings.Ranges) |
||||||
|
return; |
||||||
|
int startPos = pos; |
||||||
|
ILVariable containerVar = null; |
||||||
|
// The container length access may be a separate instruction, or it may be inline with the variable's use
|
||||||
|
if (MatchContainerLengthStore(block.Instructions[pos], out ILVariable containerLengthVar, ref containerVar)) { |
||||||
|
// stloc containerLengthVar(call get_Length/get_Count(ldloc container))
|
||||||
|
pos++; |
||||||
|
} else { |
||||||
|
// Reset if MatchContainerLengthStore only had a partial match. MatchGetOffset() will then set `containerVar`.
|
||||||
|
containerLengthVar = null; |
||||||
|
containerVar = null; |
||||||
|
} |
||||||
|
if (block.Instructions[pos].MatchStLoc(out var rangeVar, out var rangeVarInit) && rangeVar.Type.IsKnownType(KnownTypeCode.Range)) { |
||||||
|
// stloc rangeVar(rangeVarInit)
|
||||||
|
pos++; |
||||||
|
} else { |
||||||
|
rangeVar = null; |
||||||
|
rangeVarInit = null; |
||||||
|
} |
||||||
|
// stloc startOffsetVar(call GetOffset(startIndexLoad, ldloc length))
|
||||||
|
if (!block.Instructions[pos].MatchStLoc(out ILVariable startOffsetVar, out ILInstruction startOffsetVarInit)) |
||||||
|
return; |
||||||
|
if (!(startOffsetVar.IsSingleDefinition && startOffsetVar.StackType == StackType.I4)) |
||||||
|
return; |
||||||
|
var startIndexKind = MatchGetOffset(startOffsetVarInit, out ILInstruction startIndexLoad, containerLengthVar, ref containerVar); |
||||||
|
pos++; |
||||||
|
if (startOffsetVar.LoadCount == 1) { |
||||||
|
TransformIndexing(); |
||||||
|
} else if (startOffsetVar.LoadCount == 2) { |
||||||
|
// might be slicing: startOffset is used once for the slice length calculation, and once for the Slice() method call
|
||||||
|
TransformSlicing(); |
||||||
|
} |
||||||
|
|
||||||
|
void TransformIndexing() |
||||||
|
{ |
||||||
|
// complex_expr(call get_Item(ldloc container, ldloc startOffsetVar))
|
||||||
|
|
||||||
|
if (rangeVar != null) |
||||||
|
return; |
||||||
|
if (!(startOffsetVar.LoadInstructions.Single().Parent is CallInstruction call)) |
||||||
|
return; |
||||||
|
if (call.Method.AccessorKind == System.Reflection.MethodSemanticsAttributes.Getter && call.Arguments.Count == 2) { |
||||||
|
if (call.Method.AccessorOwner?.SymbolKind != SymbolKind.Indexer) |
||||||
|
return; |
||||||
|
if (call.Method.Parameters.Count != 1) |
||||||
|
return; |
||||||
|
} else if (call.Method.AccessorKind == System.Reflection.MethodSemanticsAttributes.Setter && call.Arguments.Count == 3) { |
||||||
|
if (call.Method.AccessorOwner?.SymbolKind != SymbolKind.Indexer) |
||||||
|
return; |
||||||
|
if (call.Method.Parameters.Count != 2) |
||||||
|
return; |
||||||
|
} else if (IsSlicingMethod(call.Method)) { |
||||||
|
TransformSlicing(sliceLengthWasMisdetectedAsStartOffset: true); |
||||||
|
return; |
||||||
|
} else { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (startIndexKind == IndexKind.FromStart) { |
||||||
|
// FromStart is only relevant for slicing; indexing from the start does not involve System.Index at all.
|
||||||
|
return; |
||||||
|
} |
||||||
|
if (!CheckContainerLengthVariableUseCount(containerLengthVar, startIndexKind)) { |
||||||
|
return; |
||||||
|
} |
||||||
|
// startOffsetVar might be used deep inside a complex statement, ensure we can inline up to that point:
|
||||||
|
for (int i = startPos; i < pos; i++) { |
||||||
|
if (!ILInlining.CanInlineInto(block.Instructions[pos], startOffsetVar, block.Instructions[i])) |
||||||
|
return; |
||||||
|
} |
||||||
|
if (!call.Method.Parameters[0].Type.IsKnownType(KnownTypeCode.Int32)) |
||||||
|
return; |
||||||
|
if (!MatchContainerVar(call.Arguments[0], ref containerVar)) |
||||||
|
return; |
||||||
|
if (!call.Arguments[1].MatchLdLoc(startOffsetVar)) |
||||||
|
return; |
||||||
|
var specialMethods = new IndexMethods(context.TypeSystem); |
||||||
|
if (!specialMethods.IsValid) |
||||||
|
return; |
||||||
|
if (!CSharpWillGenerateIndexer(call.Method.DeclaringType, slicing: false)) |
||||||
|
return; |
||||||
|
|
||||||
|
context.Step($"{call.Method.Name} indexed with {startIndexKind}", call); |
||||||
|
var newMethod = new SyntheticRangeIndexAccessor(call.Method, specialMethods.IndexType, slicing: false); |
||||||
|
var newCall = CallInstruction.Create(call.OpCode, newMethod); |
||||||
|
newCall.ConstrainedTo = call.ConstrainedTo; |
||||||
|
newCall.ILStackWasEmpty = call.ILStackWasEmpty; |
||||||
|
newCall.Arguments.Add(call.Arguments[0]); |
||||||
|
newCall.Arguments.Add(MakeIndex(startIndexKind, startIndexLoad, specialMethods)); |
||||||
|
newCall.Arguments.AddRange(call.Arguments.Skip(2)); |
||||||
|
newCall.AddILRange(call); |
||||||
|
for (int i = startPos; i < pos; i++) { |
||||||
|
newCall.AddILRange(block.Instructions[i]); |
||||||
|
} |
||||||
|
call.ReplaceWith(newCall); |
||||||
|
block.Instructions.RemoveRange(startPos, pos - startPos); |
||||||
|
} |
||||||
|
|
||||||
|
void TransformSlicing(bool sliceLengthWasMisdetectedAsStartOffset = false) |
||||||
|
{ |
||||||
|
ILVariable sliceLengthVar; |
||||||
|
ILInstruction sliceLengthVarInit; |
||||||
|
if (sliceLengthWasMisdetectedAsStartOffset) { |
||||||
|
// Special case: when slicing without a start point, the slice length calculation is mis-detected as the start offset,
|
||||||
|
// and since it only has a single use, we end in TransformIndexing(), which then calls TransformSlicing
|
||||||
|
// on this code path.
|
||||||
|
sliceLengthVar = startOffsetVar; |
||||||
|
sliceLengthVarInit = ((StLoc)sliceLengthVar.StoreInstructions.Single()).Value; |
||||||
|
startOffsetVar = null; |
||||||
|
startIndexLoad = new LdcI4(0); |
||||||
|
startIndexKind = IndexKind.TheStart; |
||||||
|
} else { |
||||||
|
// stloc containerLengthVar(call get_Length(ldloc containerVar))
|
||||||
|
// stloc startOffset(call GetOffset(startIndexLoad, ldloc length))
|
||||||
|
// -- we are here --
|
||||||
|
// stloc sliceLengthVar(binary.sub.i4(call GetOffset(endIndexLoad, ldloc length), ldloc startOffset))
|
||||||
|
// complex_expr(call Slice(ldloc containerVar, ldloc startOffset, ldloc sliceLength))
|
||||||
|
|
||||||
|
if (!block.Instructions[pos].MatchStLoc(out sliceLengthVar, out sliceLengthVarInit)) |
||||||
|
return; |
||||||
|
pos++; |
||||||
|
} |
||||||
|
|
||||||
|
if (!(sliceLengthVar.IsSingleDefinition && sliceLengthVar.LoadCount == 1)) |
||||||
|
return; |
||||||
|
if (!MatchSliceLength(sliceLengthVarInit, out IndexKind endIndexKind, out ILInstruction endIndexLoad, containerLengthVar, ref containerVar, startOffsetVar)) |
||||||
|
return; |
||||||
|
if (!CheckContainerLengthVariableUseCount(containerLengthVar, startIndexKind, endIndexKind)) { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (rangeVar != null) { |
||||||
|
if (!MatchIndexFromRange(startIndexKind, startIndexLoad, rangeVar, "get_Start")) |
||||||
|
return; |
||||||
|
if (!MatchIndexFromRange(endIndexKind, endIndexLoad, rangeVar, "get_End")) |
||||||
|
return; |
||||||
|
} |
||||||
|
if (!(sliceLengthVar.LoadInstructions.Single().Parent is CallInstruction call)) |
||||||
|
return; |
||||||
|
if (!IsSlicingMethod(call.Method)) |
||||||
|
return; |
||||||
|
if (call.Arguments.Count != 3) |
||||||
|
return; |
||||||
|
if (!MatchContainerVar(call.Arguments[0], ref containerVar)) |
||||||
|
return; |
||||||
|
if (startOffsetVar == null) { |
||||||
|
Debug.Assert(startIndexKind == IndexKind.TheStart); |
||||||
|
if (!call.Arguments[1].MatchLdcI4(0)) |
||||||
|
return; |
||||||
|
} else { |
||||||
|
if (!call.Arguments[1].MatchLdLoc(startOffsetVar)) |
||||||
|
return; |
||||||
|
} |
||||||
|
if (!call.Arguments[2].MatchLdLoc(sliceLengthVar)) |
||||||
|
return; |
||||||
|
if (!CSharpWillGenerateIndexer(call.Method.DeclaringType, slicing: true)) |
||||||
|
return; |
||||||
|
if (startIndexKind == IndexKind.FromStart && endIndexKind == IndexKind.FromStart) { |
||||||
|
// It's possible we actually have a startIndex/endIndex that involves the container length,
|
||||||
|
// but we couldn't detect it yet because the statement initializing the containerLengthVar is
|
||||||
|
// not yet part of the region to be transformed.
|
||||||
|
// If we transform now, we'd end up with:
|
||||||
|
// int length = span.Length;
|
||||||
|
// Console.WriteLine(span[(length - GetInt(1))..(length - GetInt(2))].ToString());
|
||||||
|
// which is correct but unnecessarily complex.
|
||||||
|
// So we peek ahead at the next instruction to be transformed:
|
||||||
|
if (startPos > 0 && MatchContainerLengthStore(block.Instructions[startPos - 1], out _, ref containerVar)) { |
||||||
|
// Looks like the transform would be able do to a better job including that previous instruction,
|
||||||
|
// so let's avoid transforming just yet.
|
||||||
|
return; |
||||||
|
} |
||||||
|
// Something similar happens with the rangeVar:
|
||||||
|
if (startPos > 0 && block.Instructions[startPos - 1] is StLoc stloc && stloc.Variable.Type.IsKnownType(KnownTypeCode.Range)) { |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
var specialMethods = new IndexMethods(context.TypeSystem); |
||||||
|
if (!specialMethods.IsValid) |
||||||
|
return; |
||||||
|
|
||||||
|
context.Step($"{call.Method.Name} sliced with {startIndexKind}..{endIndexKind}", call); |
||||||
|
var newMethod = new SyntheticRangeIndexAccessor(call.Method, specialMethods.RangeType, slicing: true); |
||||||
|
var newCall = CallInstruction.Create(call.OpCode, newMethod); |
||||||
|
newCall.ConstrainedTo = call.ConstrainedTo; |
||||||
|
newCall.ILStackWasEmpty = call.ILStackWasEmpty; |
||||||
|
newCall.Arguments.Add(call.Arguments[0]); |
||||||
|
if (rangeVar != null) { |
||||||
|
newCall.Arguments.Add(rangeVarInit); |
||||||
|
} else if (startIndexKind == IndexKind.TheStart && endIndexKind == IndexKind.TheEnd && specialMethods.RangeGetAll != null) { |
||||||
|
newCall.Arguments.Add(new Call(specialMethods.RangeGetAll)); |
||||||
|
} else if (startIndexKind == IndexKind.TheStart && specialMethods.RangeEndAt != null) { |
||||||
|
var rangeCtorCall = new Call(specialMethods.RangeEndAt); |
||||||
|
rangeCtorCall.Arguments.Add(MakeIndex(endIndexKind, endIndexLoad, specialMethods)); |
||||||
|
newCall.Arguments.Add(rangeCtorCall); |
||||||
|
} else if (endIndexKind == IndexKind.TheEnd && specialMethods.RangeStartAt != null) { |
||||||
|
var rangeCtorCall = new Call(specialMethods.RangeStartAt); |
||||||
|
rangeCtorCall.Arguments.Add(MakeIndex(startIndexKind, startIndexLoad, specialMethods)); |
||||||
|
newCall.Arguments.Add(rangeCtorCall); |
||||||
|
} else { |
||||||
|
var rangeCtorCall = new NewObj(specialMethods.RangeCtor); |
||||||
|
rangeCtorCall.Arguments.Add(MakeIndex(startIndexKind, startIndexLoad, specialMethods)); |
||||||
|
rangeCtorCall.Arguments.Add(MakeIndex(endIndexKind, endIndexLoad, specialMethods)); |
||||||
|
newCall.Arguments.Add(rangeCtorCall); |
||||||
|
} |
||||||
|
newCall.AddILRange(call); |
||||||
|
for (int i = startPos; i < pos; i++) { |
||||||
|
newCall.AddILRange(block.Instructions[i]); |
||||||
|
} |
||||||
|
call.ReplaceWith(newCall); |
||||||
|
block.Instructions.RemoveRange(startPos, pos - startPos); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static bool IsSlicingMethod(IMethod method) |
||||||
|
{ |
||||||
|
if (method.IsExtensionMethod) |
||||||
|
return false; |
||||||
|
if (method.Parameters.Count != 2) |
||||||
|
return false; |
||||||
|
if (!method.Parameters.All(p => p.Type.IsKnownType(KnownTypeCode.Int32))) |
||||||
|
return false; |
||||||
|
return method.Name == "Slice" |
||||||
|
|| (method.Name == "Substring" && method.DeclaringType.IsKnownType(KnownTypeCode.String)); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Check that the number of uses of the containerLengthVar variable matches those expected in the pattern.
|
||||||
|
/// </summary>
|
||||||
|
private bool CheckContainerLengthVariableUseCount(ILVariable containerLengthVar, IndexKind startIndexKind, IndexKind endIndexKind = IndexKind.FromStart) |
||||||
|
{ |
||||||
|
int expectedUses = 0; |
||||||
|
if (startIndexKind != IndexKind.FromStart && startIndexKind != IndexKind.TheStart) |
||||||
|
expectedUses += 1; |
||||||
|
if (endIndexKind != IndexKind.FromStart && endIndexKind != IndexKind.TheStart) |
||||||
|
expectedUses += 1; |
||||||
|
if (containerLengthVar != null) { |
||||||
|
return containerLengthVar.LoadCount == expectedUses; |
||||||
|
} else { |
||||||
|
return expectedUses <= 1; // can have one inline use
|
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Matches 'addressof System.Index(call get_Start/get_End(ldloca rangeVar))'
|
||||||
|
/// </summary>
|
||||||
|
static bool MatchIndexFromRange(IndexKind indexKind, ILInstruction indexLoad, ILVariable rangeVar, string accessorName) |
||||||
|
{ |
||||||
|
if (indexKind != IndexKind.RefSystemIndex) |
||||||
|
return false; |
||||||
|
if (!(indexLoad is AddressOf addressOf)) |
||||||
|
return false; |
||||||
|
if (!addressOf.Type.IsKnownType(KnownTypeCode.Index)) |
||||||
|
return false; |
||||||
|
if (!(addressOf.Value is Call call)) |
||||||
|
return false; |
||||||
|
if (call.Method.Name != accessorName) |
||||||
|
return false; |
||||||
|
if (!call.Method.DeclaringType.IsKnownType(KnownTypeCode.Range)) |
||||||
|
return false; |
||||||
|
if (call.Arguments.Count != 1) |
||||||
|
return false; |
||||||
|
return call.Arguments[0].MatchLdLoca(rangeVar); |
||||||
|
} |
||||||
|
|
||||||
|
static ILInstruction MakeIndex(IndexKind indexKind, ILInstruction indexLoad, IndexMethods specialMethods) |
||||||
|
{ |
||||||
|
if (indexKind == IndexKind.RefSystemIndex) { |
||||||
|
// stloc containerLengthVar(call get_Length/get_Count(ldloc container))
|
||||||
|
// stloc startOffsetVar(call GetOffset(startIndexLoad, ldloc length))
|
||||||
|
// complex_expr(call get_Item(ldloc container, ldloc startOffsetVar))
|
||||||
|
// -->
|
||||||
|
// complex_expr(call get_Item(ldloc container, ldobj startIndexLoad))
|
||||||
|
return new LdObj(indexLoad, specialMethods.IndexType); |
||||||
|
} else if (indexKind == IndexKind.FromEnd || indexKind == IndexKind.TheEnd) { |
||||||
|
// stloc offsetVar(binary.sub.i4(call get_Length/get_Count(ldloc container), startIndexLoad))
|
||||||
|
// complex_expr(call get_Item(ldloc container, ldloc startOffsetVar))
|
||||||
|
// -->
|
||||||
|
// complex_expr(call get_Item(ldloc container, newobj System.Index(startIndexLoad, fromEnd: true)))
|
||||||
|
return new NewObj(specialMethods.IndexCtor) { Arguments = { indexLoad, new LdcI4(1) } }; |
||||||
|
} else { |
||||||
|
Debug.Assert(indexKind == IndexKind.FromStart || indexKind == IndexKind.TheStart); |
||||||
|
return new Call(specialMethods.IndexImplicitConv) { Arguments = { indexLoad } }; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets whether the C# compiler will call `container[int]` when using `container[Index]`.
|
||||||
|
/// </summary>
|
||||||
|
private bool CSharpWillGenerateIndexer(IType declaringType, bool slicing) |
||||||
|
{ |
||||||
|
bool foundInt32Overload = false; |
||||||
|
bool foundIndexOverload = false; |
||||||
|
bool foundRangeOverload = false; |
||||||
|
bool foundCountProperty = false; |
||||||
|
foreach (var prop in declaringType.GetProperties(p => p.IsIndexer || (p.Name == "Length" || p.Name == "Count"))) { |
||||||
|
if (prop.IsIndexer && prop.Parameters.Count == 1) { |
||||||
|
var p = prop.Parameters[0]; |
||||||
|
if (p.Type.IsKnownType(KnownTypeCode.Int32)) { |
||||||
|
foundInt32Overload = true; |
||||||
|
} else if (p.Type.IsKnownType(KnownTypeCode.Index)) { |
||||||
|
foundIndexOverload = true; |
||||||
|
} else if (p.Type.IsKnownType(KnownTypeCode.Range)) { |
||||||
|
foundRangeOverload = true; |
||||||
|
} |
||||||
|
} else if (prop.Name == "Length" || prop.Name == "Count") { |
||||||
|
foundCountProperty = true; |
||||||
|
} |
||||||
|
} |
||||||
|
if (slicing) { |
||||||
|
return /* foundSlicingMethod && */ foundCountProperty && !foundRangeOverload; |
||||||
|
} else { |
||||||
|
return foundInt32Overload && foundCountProperty && !foundIndexOverload; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Matches the instruction:
|
||||||
|
/// stloc containerLengthVar(call get_Length/get_Count(ldloc containerVar))
|
||||||
|
/// </summary>
|
||||||
|
static bool MatchContainerLengthStore(ILInstruction inst, out ILVariable lengthVar, ref ILVariable containerVar) |
||||||
|
{ |
||||||
|
if (!inst.MatchStLoc(out lengthVar, out var init)) |
||||||
|
return false; |
||||||
|
if (!(lengthVar.IsSingleDefinition && lengthVar.StackType == StackType.I4)) |
||||||
|
return false; |
||||||
|
return MatchContainerLength(init, null, ref containerVar); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// If lengthVar is non-null, matches 'ldloc lengthVar'.
|
||||||
|
///
|
||||||
|
/// Otherwise, matches the instruction:
|
||||||
|
/// call get_Length/get_Count(ldloc containerVar)
|
||||||
|
/// </summary>
|
||||||
|
static bool MatchContainerLength(ILInstruction init, ILVariable lengthVar, ref ILVariable containerVar) |
||||||
|
{ |
||||||
|
if (lengthVar != null) { |
||||||
|
Debug.Assert(containerVar != null); |
||||||
|
return init.MatchLdLoc(lengthVar); |
||||||
|
} |
||||||
|
if (!(init is CallInstruction call)) |
||||||
|
return false; |
||||||
|
if (call.ResultType != StackType.I4) |
||||||
|
return false; |
||||||
|
if (!(call.Method.IsAccessor && call.Method.AccessorKind == System.Reflection.MethodSemanticsAttributes.Getter)) |
||||||
|
return false; |
||||||
|
if (!(call.Method.AccessorOwner is IProperty lengthProp)) |
||||||
|
return false; |
||||||
|
if (lengthProp.Name == "Length") { |
||||||
|
// OK, Length is preferred
|
||||||
|
} else if (lengthProp.Name == "Count") { |
||||||
|
// Also works, but only if the type doesn't have "Length"
|
||||||
|
if (lengthProp.DeclaringType.GetProperties(p => p.Name == "Length").Any()) |
||||||
|
return false; |
||||||
|
} |
||||||
|
if (!lengthProp.ReturnType.IsKnownType(KnownTypeCode.Int32)) |
||||||
|
return false; |
||||||
|
if (lengthProp.IsVirtual && call.OpCode != OpCode.CallVirt) |
||||||
|
return false; |
||||||
|
if (call.Arguments.Count != 1) |
||||||
|
return false; |
||||||
|
return MatchContainerVar(call.Arguments[0], ref containerVar); |
||||||
|
} |
||||||
|
|
||||||
|
static bool MatchContainerVar(ILInstruction inst, ref ILVariable containerVar) |
||||||
|
{ |
||||||
|
if (containerVar != null) { |
||||||
|
return inst.MatchLdLoc(containerVar) || inst.MatchLdLoca(containerVar); |
||||||
|
} else { |
||||||
|
return inst.MatchLdLoc(out containerVar) || inst.MatchLdLoca(out containerVar); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
enum IndexKind |
||||||
|
{ |
||||||
|
/// <summary>
|
||||||
|
/// indexLoad is an integer, from the start of the container
|
||||||
|
/// </summary>
|
||||||
|
FromStart, |
||||||
|
/// <summary>
|
||||||
|
/// indexLoad is loading the address of a System.Index struct
|
||||||
|
/// </summary>
|
||||||
|
RefSystemIndex, |
||||||
|
/// <summary>
|
||||||
|
/// indexLoad is an integer, from the end of the container
|
||||||
|
/// </summary>
|
||||||
|
FromEnd, |
||||||
|
/// <summary>
|
||||||
|
/// Always equivalent to `0`, used for the start-index when slicing without a startpoint `a[..end]`
|
||||||
|
/// </summary>
|
||||||
|
TheStart, |
||||||
|
/// <summary>
|
||||||
|
/// Always equivalent to `^0`, used for the end-index when slicing without an endpoint `a[start..]`
|
||||||
|
/// </summary>
|
||||||
|
TheEnd, |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Matches an instruction computing an offset:
|
||||||
|
/// call System.Index.GetOffset(indexLoad, ldloc containerLengthVar)
|
||||||
|
/// or
|
||||||
|
/// binary.sub.i4(ldloc containerLengthVar, indexLoad)
|
||||||
|
///
|
||||||
|
/// Anything else not matching these patterns is interpreted as an `int` expression from the start of the container.
|
||||||
|
/// </summary>
|
||||||
|
static IndexKind MatchGetOffset(ILInstruction inst, out ILInstruction indexLoad, |
||||||
|
ILVariable containerLengthVar, ref ILVariable containerVar) |
||||||
|
{ |
||||||
|
indexLoad = inst; |
||||||
|
if (MatchContainerLength(inst, containerLengthVar, ref containerVar)) { |
||||||
|
indexLoad = new LdcI4(0); |
||||||
|
return IndexKind.TheEnd; |
||||||
|
} else if (inst is CallInstruction call) { |
||||||
|
// call System.Index.GetOffset(indexLoad, ldloc containerLengthVar)
|
||||||
|
if (call.Method.Name != "GetOffset") |
||||||
|
return IndexKind.FromStart; |
||||||
|
if (!call.Method.DeclaringType.IsKnownType(KnownTypeCode.Index)) |
||||||
|
return IndexKind.FromStart; |
||||||
|
if (call.Arguments.Count != 2) |
||||||
|
return IndexKind.FromStart; |
||||||
|
if (!MatchContainerLength(call.Arguments[1], containerLengthVar, ref containerVar)) |
||||||
|
return IndexKind.FromStart; |
||||||
|
indexLoad = call.Arguments[0]; |
||||||
|
return IndexKind.RefSystemIndex; |
||||||
|
} else if (inst is BinaryNumericInstruction bni && bni.Operator == BinaryNumericOperator.Sub) { |
||||||
|
if (bni.CheckForOverflow || bni.ResultType != StackType.I4 || bni.IsLifted) |
||||||
|
return IndexKind.FromStart; |
||||||
|
// binary.sub.i4(ldloc containerLengthVar, indexLoad)
|
||||||
|
if (!MatchContainerLength(bni.Left, containerLengthVar, ref containerVar)) |
||||||
|
return IndexKind.FromStart; |
||||||
|
indexLoad = bni.Right; |
||||||
|
return IndexKind.FromEnd; |
||||||
|
} else { |
||||||
|
return IndexKind.FromStart; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Matches an instruction computing a slice length:
|
||||||
|
/// binary.sub.i4(call GetOffset(endIndexLoad, ldloc length), ldloc startOffset))
|
||||||
|
/// </summary>
|
||||||
|
static bool MatchSliceLength(ILInstruction inst, out IndexKind endIndexKind, out ILInstruction endIndexLoad, ILVariable containerLengthVar, ref ILVariable containerVar, ILVariable startOffsetVar) |
||||||
|
{ |
||||||
|
endIndexKind = default; |
||||||
|
endIndexLoad = default; |
||||||
|
if (inst is BinaryNumericInstruction bni && bni.Operator == BinaryNumericOperator.Sub) { |
||||||
|
if (bni.CheckForOverflow || bni.ResultType != StackType.I4 || bni.IsLifted) |
||||||
|
return false; |
||||||
|
if (startOffsetVar == null) { |
||||||
|
// When slicing without explicit start point: `a[..endIndex]`
|
||||||
|
if (!bni.Right.MatchLdcI4(0)) |
||||||
|
return false; |
||||||
|
} else { |
||||||
|
if (!bni.Right.MatchLdLoc(startOffsetVar)) |
||||||
|
return false; |
||||||
|
} |
||||||
|
endIndexKind = MatchGetOffset(bni.Left, out endIndexLoad, containerLengthVar, ref containerVar); |
||||||
|
return true; |
||||||
|
} else if (startOffsetVar == null) { |
||||||
|
// When slicing without explicit start point: `a[..endIndex]`, the compiler doesn't always emit the "- 0".
|
||||||
|
endIndexKind = MatchGetOffset(inst, out endIndexLoad, containerLengthVar, ref containerVar); |
||||||
|
return true; |
||||||
|
} else { |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,137 @@ |
|||||||
|
// Copyright (c) 2020 Daniel Grunwald
|
||||||
|
//
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||||
|
// software and associated documentation files (the "Software"), to deal in the Software
|
||||||
|
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||||
|
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||||
|
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||||
|
//
|
||||||
|
// The above copyright notice and this permission notice shall be included in all copies or
|
||||||
|
// substantial portions of the Software.
|
||||||
|
//
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||||
|
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||||
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||||
|
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||||
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
// DEALINGS IN THE SOFTWARE.
|
||||||
|
|
||||||
|
using System.Collections.Generic; |
||||||
|
using ICSharpCode.Decompiler.Util; |
||||||
|
using System.Reflection; |
||||||
|
using System.Reflection.Metadata; |
||||||
|
using System.Diagnostics; |
||||||
|
using System.Linq; |
||||||
|
|
||||||
|
namespace ICSharpCode.Decompiler.TypeSystem.Implementation |
||||||
|
{ |
||||||
|
/// <summary>
|
||||||
|
/// Synthetic method representing a compiler-generated indexer
|
||||||
|
/// with the signature 'get_Item(System.Index)' or 'get_Item(System.Range)'.
|
||||||
|
/// Can also be a setter.
|
||||||
|
/// Used for the "Implicit Index support"/"Implicit Range support" for the C# 8 ranges feature.
|
||||||
|
/// </summary>
|
||||||
|
class SyntheticRangeIndexAccessor : IMethod |
||||||
|
{ |
||||||
|
/// <summary>
|
||||||
|
/// The underlying method: `get_Item(int)`, `set_Item(int, T)` or `Slice(int, int)`.
|
||||||
|
/// </summary>
|
||||||
|
readonly IMethod underlyingMethod; |
||||||
|
readonly IType indexOrRangeType; |
||||||
|
readonly IReadOnlyList<IParameter> parameters; |
||||||
|
readonly bool slicing; |
||||||
|
|
||||||
|
public SyntheticRangeIndexAccessor(IMethod underlyingMethod, IType indexOrRangeType, bool slicing) |
||||||
|
{ |
||||||
|
Debug.Assert(underlyingMethod != null); |
||||||
|
Debug.Assert(indexOrRangeType != null); |
||||||
|
this.underlyingMethod = underlyingMethod; |
||||||
|
this.indexOrRangeType = indexOrRangeType; |
||||||
|
this.slicing = slicing; |
||||||
|
var parameters = new List<IParameter>(); |
||||||
|
parameters.Add(new DefaultParameter(indexOrRangeType, "")); |
||||||
|
if (slicing) { |
||||||
|
Debug.Assert(underlyingMethod.Parameters.Count == 2); |
||||||
|
} else { |
||||||
|
parameters.AddRange(underlyingMethod.Parameters.Skip(1)); |
||||||
|
} |
||||||
|
this.parameters = parameters; |
||||||
|
} |
||||||
|
|
||||||
|
public bool IsSlicing => slicing; |
||||||
|
|
||||||
|
bool IMethod.ReturnTypeIsRefReadOnly => underlyingMethod.ReturnTypeIsRefReadOnly; |
||||||
|
bool IMethod.ThisIsRefReadOnly => underlyingMethod.ThisIsRefReadOnly; |
||||||
|
|
||||||
|
IReadOnlyList<ITypeParameter> IMethod.TypeParameters => EmptyList<ITypeParameter>.Instance; |
||||||
|
IReadOnlyList<IType> IMethod.TypeArguments => EmptyList<IType>.Instance; |
||||||
|
|
||||||
|
bool IMethod.IsExtensionMethod => false; |
||||||
|
bool IMethod.IsLocalFunction => false; |
||||||
|
bool IMethod.IsConstructor => false; |
||||||
|
bool IMethod.IsDestructor => false; |
||||||
|
bool IMethod.IsOperator => false; |
||||||
|
bool IMethod.HasBody => underlyingMethod.HasBody; |
||||||
|
bool IMethod.IsAccessor => underlyingMethod.IsAccessor; |
||||||
|
IMember IMethod.AccessorOwner => underlyingMethod.AccessorOwner; |
||||||
|
MethodSemanticsAttributes IMethod.AccessorKind => underlyingMethod.AccessorKind; |
||||||
|
IMethod IMethod.ReducedFrom => underlyingMethod.ReducedFrom; |
||||||
|
IReadOnlyList<IParameter> IParameterizedMember.Parameters => parameters; |
||||||
|
IMember IMember.MemberDefinition => underlyingMethod.MemberDefinition; |
||||||
|
IType IMember.ReturnType => underlyingMethod.ReturnType; |
||||||
|
IEnumerable<IMember> IMember.ExplicitlyImplementedInterfaceMembers => EmptyList<IMember>.Instance; |
||||||
|
bool IMember.IsExplicitInterfaceImplementation => false; |
||||||
|
bool IMember.IsVirtual => underlyingMethod.IsVirtual; |
||||||
|
bool IMember.IsOverride => underlyingMethod.IsOverride; |
||||||
|
bool IMember.IsOverridable => underlyingMethod.IsOverridable; |
||||||
|
TypeParameterSubstitution IMember.Substitution => underlyingMethod.Substitution; |
||||||
|
EntityHandle IEntity.MetadataToken => underlyingMethod.MetadataToken; |
||||||
|
public string Name => underlyingMethod.Name; |
||||||
|
IType IEntity.DeclaringType => underlyingMethod.DeclaringType; |
||||||
|
ITypeDefinition IEntity.DeclaringTypeDefinition => underlyingMethod.DeclaringTypeDefinition; |
||||||
|
IModule IEntity.ParentModule => underlyingMethod.ParentModule; |
||||||
|
Accessibility IEntity.Accessibility => underlyingMethod.Accessibility; |
||||||
|
bool IEntity.IsStatic => underlyingMethod.IsStatic; |
||||||
|
bool IEntity.IsAbstract => underlyingMethod.IsAbstract; |
||||||
|
bool IEntity.IsSealed => underlyingMethod.IsSealed; |
||||||
|
SymbolKind ISymbol.SymbolKind => SymbolKind.Method; |
||||||
|
ICompilation ICompilationProvider.Compilation => underlyingMethod.Compilation; |
||||||
|
string INamedElement.FullName => underlyingMethod.FullName; |
||||||
|
string INamedElement.ReflectionName => underlyingMethod.ReflectionName; |
||||||
|
string INamedElement.Namespace => underlyingMethod.Namespace; |
||||||
|
|
||||||
|
public override bool Equals(object obj) |
||||||
|
{ |
||||||
|
return obj is SyntheticRangeIndexAccessor g |
||||||
|
&& this.underlyingMethod.Equals(g.underlyingMethod) |
||||||
|
&& this.indexOrRangeType.Equals(g.indexOrRangeType) |
||||||
|
&& this.slicing == g.slicing; |
||||||
|
} |
||||||
|
|
||||||
|
public override int GetHashCode() |
||||||
|
{ |
||||||
|
return underlyingMethod.GetHashCode() ^ indexOrRangeType.GetHashCode(); |
||||||
|
} |
||||||
|
|
||||||
|
bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) |
||||||
|
{ |
||||||
|
return obj is SyntheticRangeIndexAccessor g |
||||||
|
&& this.underlyingMethod.Equals(g.underlyingMethod, typeNormalization) |
||||||
|
&& this.indexOrRangeType.AcceptVisitor(typeNormalization).Equals(g.indexOrRangeType.AcceptVisitor(typeNormalization)); |
||||||
|
} |
||||||
|
|
||||||
|
IEnumerable<IAttribute> IEntity.GetAttributes() => underlyingMethod.GetAttributes(); |
||||||
|
|
||||||
|
IEnumerable<IAttribute> IMethod.GetReturnTypeAttributes() => underlyingMethod.GetReturnTypeAttributes(); |
||||||
|
|
||||||
|
IMethod IMethod.Specialize(TypeParameterSubstitution substitution) |
||||||
|
{ |
||||||
|
return new SyntheticRangeIndexAccessor(underlyingMethod.Specialize(substitution), indexOrRangeType, slicing); |
||||||
|
} |
||||||
|
|
||||||
|
IMember IMember.Specialize(TypeParameterSubstitution substitution) |
||||||
|
{ |
||||||
|
return new SyntheticRangeIndexAccessor(underlyingMethod.Specialize(substitution), indexOrRangeType, slicing); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue