public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args, InvocationExpressionSyntax invocation)
{
var access = (MemberAccessExpressionSyntax)invocation.Expression;
var name = (GenericNameSyntax)access.Name;
var type = name.TypeArgumentList.Arguments[0];
var typeSymbol = design.Semantic.GetTypeInfo(type).Type;
if (SymbolExtensions.IsSameType(typeSymbol, design.LastValue.Type))
{
}
else if (design.Unchecked || SymbolExtensions.IsDescendantType(typeSymbol, design.LastValue.Type))
{
design.LastValue = design.LastValue.Reusable(design);
design.ForAdd(If(Not(design.LastValue.Is(type)),
Continue()));
design.LastValue = new TypedValueBridge(type, design.LastValue.Cast(type));
}
else
{
design.LastValue = design.LastValue.Reusable(design);
design.ForAdd(If(Not(design.LastValue.Is(type)),
Continue()));
design.LastValue = new TypedValueBridge(type, design.LastValue.Cast(ParseTypeName("object")).Cast(type));
}
design.ResultSize = null;
design.ListEnumeration = false;
design.ModifiedEnumeration = true;
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var listVariable = CreateGlobalVariable(design, design.ReturnType, New(design.ReturnType));
design.ForAdd(listVariable.Access("Add").Invoke(design.LastValue));
design.ResultAdd(Return(listVariable));
}
public void CalculatePreAdd(RewriteDesign design)
{
if (_preAddCalculated)
{
return;
}
_preAddCalculated = true;
ForBody.ForEach(statement =>
{
if (statement is IteratorDesign iteratorParameters)
{
iteratorParameters.CalculatePreAdd(design);
}
});
if (ForFrom == null)
{
PreFor.Insert(0, (StatementBridge)Enumerator.Assign(Collection.Access("GetEnumerator").Invoke()));
}
else if (IsReversed)
{
PreFor.Add((StatementBridge)ForIndexer.Assign(ForFrom));
ForTo = ForTo.ReusableForConst(_design, Int, this);
}
else
{
PreFor.Add((StatementBridge)ForIndexer.Assign(ForFrom));
ForTo = (ForTo + 1).ReusableForConst(_design, Int, this);
}
}
private static void UnknownSourceSize(RewriteDesign design)
{
design.Indexer = null;
var reverseIndexerVariable = CreateGlobalVariable(design, Int, 8);
var currentLengthVariable = CreateGlobalVariable(design, Int, 8);
var resultVariable = CreateGlobalVariable(design, design.LastValue.ArrayType(), CreateArray(design.LastValue.ArrayType(), 8));
var sizeVariable = CreateGlobalVariable(design, Int);
design.ForAdd(reverseIndexerVariable.PreDecrement());
design.ForAdd(If(reverseIndexerVariable < 0,
Block(
sizeVariable.Assign(currentLengthVariable),
"LinqRewrite".Access("Core", "EnlargeExtensions", "LogEnlargeReverseArray")
.Invoke(2, RefArg(resultVariable), RefArg(currentLengthVariable)),
reverseIndexerVariable.Assign(currentLengthVariable - sizeVariable - 1))));
design.ForAdd(resultVariable[reverseIndexerVariable].Assign(design.LastValue));
design.Indexer = null;
design.Iterators.All.ForEach(x => x.Complete = true);
design.AddIterator(new CollectionValueBridge(design, resultVariable.Type, design.LastValue.Type, resultVariable, true));
design.CurrentCollection = design.CurrentIterator.Collection;
RewriteCollectionEnumeration.RewriteOther(design, design.CurrentCollection);
design.ResultSize = design.SourceSize = currentLengthVariable - reverseIndexerVariable;
design.CurrentIterator.ForFrom = reverseIndexerVariable;
design.CurrentIterator.ForTo = currentLengthVariable - 1;
design.Indexer = null;
}
public StatementSyntax[] GetStatementSyntax(RewriteDesign design)
{
CalculatePreAdd(design);
if (IgnoreIterator)
{
return(Array.Empty <StatementSyntax>());
}
var content = ForBody.SelectMany(statement =>
statement is IteratorDesign parameters
? parameters.PreFor.Select(statement => (StatementBridge)statement).Concat(new[] { statement })
.Concat(parameters.PostFor.Select(statement => (StatementBridge)statement))
: new[] { statement }).Concat(ForEnd).ToList();
if (ForFrom == null)
{
return(RewriteService.GetForEachStatement(design, Enumerator, content));
}
if (IsReversed)
{
return new StatementSyntax[] { RewriteService.GetReverseForStatement(design, ForIndexer, ForTo, ForInc, content) }
}
;
return(new StatementSyntax[] { RewriteService.GetForStatement(design, ForIndexer, ForTo, ForInc, content) });
}
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args, InvocationExpressionSyntax invocation)
{
var access = (MemberAccessExpressionSyntax)invocation.Expression;
var name = (GenericNameSyntax)access.Name;
var type = name.TypeArgumentList.Arguments[0];
var typeSymbol = design.Semantic.GetTypeInfo(type).Type;
if (SymbolExtensions.IsSameType(typeSymbol, design.LastValue.Type))
{
;
}
else if (design.Unchecked || SymbolExtensions.IsDescendantType(typeSymbol, design.LastValue.Type))
{
design.LastValue = new TypedValueBridge(type, design.LastValue.Cast(type));
if (!design.Unchecked)
{
design.ListEnumeration = false;
}
}
else
{
design.LastValue = new TypedValueBridge(type, design.LastValue.Cast(ParseTypeName("object")).Cast(type));
design.ListEnumeration = false;
}
}
private static bool CheckBounds(RewriteDesign design, ref RewrittenValueBridge skippedValue)
{
if (design.ResultSize == null)
{
return(true);
}
if (TryGetInt(skippedValue, out var skippedInt))
{
if (skippedInt <= 0)
{
return(false);
}
if (TryGetInt(design.ResultSize, out var resultSizeInt) && skippedInt > resultSizeInt)
{
skippedValue = new RewrittenValueBridge(design.ResultSize);
}
else if (!design.Unchecked)
{
var skippedVariable = CreateGlobalVariable(design, Int);
design.InitialAdd(skippedVariable.Assign(ConditionalExpression(skippedValue > design.ResultSize,
design.ResultSize, skippedValue)));
skippedValue = new RewrittenValueBridge(skippedVariable);
}
}
else if (!design.Unchecked && !design.ModifiedEnumeration)
{
var skippedVariable = CreateGlobalVariable(design, Int);
design.InitialAdd(If(skippedValue < 0, skippedVariable.Assign(0),
If(skippedValue > design.ResultSize, skippedVariable.Assign(design.ResultSize),
skippedVariable.Assign(skippedValue))));
skippedValue = new RewrittenValueBridge(skippedVariable);
}
return(true);
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (design.Iterators.Count > 1)
{
design.ListEnumeration = false;
}
var takeValue = args[0];
CheckBounds(design, ref takeValue);
LocalVariable takeIndexer = CreateGlobalVariable(design, Int, 0);
if (!design.ModifiedEnumeration)
{
design.CurrentIterator.ForTo = design.CurrentIterator.ForFrom + design.CurrentIterator.ForInc * takeValue - design.CurrentIterator.ForInc;
design.CurrentIterator.ForTo = design.CurrentIterator.ForTo;
}
else
{
design.ForAdd(If(takeIndexer.PostIncrement() >= takeValue, Break()));
}
if (design.ResultSize != null)
{
design.ResultSize = takeValue;
}
else
{
design.SourceSize = takeValue;
}
design.Indexer = null;
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
design.Variables.Where(variable => !variable.IsGlobal).ForEach(variable => variable.IsUsed = false);
var itemValue = args[0];
var countValue = args[1];
if (!AssertGreaterEqual(design, countValue, 0))
{
return;
}
design.AddIterator();
design.CurrentIterator.ForFrom = 0;
design.CurrentIterator.ForTo = countValue - 1;
design.CurrentIterator.ForIndexer = CreateLocalVariable(design, Int);
design.ResultSize = countValue;
design.SourceSize = countValue;
design.ListEnumeration = false;
design.SimpleEnumeration = true;
if (design.CurrentIndexer == null)
{
design.CurrentIterator.Indexer = design.CurrentIterator.ForIndexer;
design.CurrentIterator.Indexer.IsGlobal = true;
}
design.LastValue = new TypedValueBridge(itemValue.GetType(design), itemValue);
design.FirstCollection = design.CurrentCollection = null;
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args, InvocationExpressionSyntax invocation)
{
design.Variables.Where(variable => !variable.IsGlobal).ForEach(variable => variable.IsUsed = false);
var access = (MemberAccessExpressionSyntax)invocation.Expression;
var name = (GenericNameSyntax)access.Name;
var type = name.TypeArgumentList.Arguments[0];
if (design.RewriteChain.Count == 1)
{
design.NotRewrite = true;
return;
}
design.FirstCollection = design.CurrentCollection = null;
design.AddIterator();
design.CurrentIterator.IgnoreIterator = true;
design.CurrentIterator.ForFrom = 0;
design.CurrentIterator.ForTo = 0;
design.CurrentIterator.ForIndexer = CreateLocalVariable(design, Int, 0);
design.ResultSize = 0;
design.SourceSize = 0;
design.ListEnumeration = false;
design.SimpleEnumeration = true;
if (design.CurrentIndexer == null)
{
design.CurrentIterator.Indexer = design.CurrentIterator.ForIndexer;
design.CurrentIterator.Indexer.IsGlobal = true;
}
design.LastValue = new TypedValueBridge(type, Default(type));
design.CurrentCollection = null;
}
public static void ArrayEnumeration(RewriteDesign design, TypeBridge itemType, ValueBridge count, ValueBridge collection, LocalVariable variable = null)
{
design.CurrentIterator.ForFrom = 0;
design.CurrentIterator.ForTo = count - 1;
design.CurrentIterator.ForIndexer = CreateGlobalVariable(design, Int);
if (design.CurrentIndexer == null)
{
design.CurrentIterator.Indexer = design.CurrentIterator.ForIndexer;
design.CurrentIterator.Indexer.IsGlobal = true;
}
if (variable == null)
{
design.LastValue = new TypedValueBridge(itemType, collection[design.CurrentIterator.ForIndexer]);
}
else
{
design.CurrentIterator.BodyAdd(variable.Assign(collection[design.CurrentIterator.ForIndexer]));
design.LastValue = new TypedValueBridge(itemType, variable);
}
design.ResultSize = count;
design.SourceSize = count;
design.SimpleEnumeration = true;
design.ListEnumeration = true;
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var collectionValue = args[0];
if (!AssertNotNull(design, collectionValue))
{
return;
}
var methodValue = args[1];
design.WrapWithTry = true;
var itemType = collectionValue.ItemType(design);
var enumeratorVariable = CreateGlobalVariable(design, ParseTypeName($"System.Collections.Generic.IEnumerator<{itemType}>"));
design.InitialAdd(enumeratorVariable.Assign(Parenthesize(collectionValue.Cast(ParseTypeName($"IEnumerable<{itemType}>")))
.Access("GetEnumerator").Invoke()));
design.ForAdd(If(Not(enumeratorVariable.Access("MoveNext").Invoke()), Break()));
design.LastValue = methodValue.Inline(design, design.LastValue, new TypedValueBridge(collectionValue.ItemType(design), enumeratorVariable.Access("Current")));
design.FinalAdd(enumeratorVariable.Access("Dispose").Invoke());
design.ListEnumeration = false;
design.ModifiedEnumeration = true;
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var enlarging = args.FirstOrDefault()?.ToString() switch
{
"EnlargingCoefficient.By2" => 1,
"EnlargingCoefficient.By4" => 2,
"EnlargingCoefficient.By8" => 3,
_ when design.SourceSize != null => 2,
_ => 1
};
var(currentLength, currentResult) = RewriteToArray.GetResultVariable(design, design.LastValue.Type);
VariableBridge result = RewriteToArray.RewriteOther(design, currentLength, currentResult, enlarging);
RewriteToArray.SimplifyPart(design, result);
var listResultType = ParseTypeName($"LinqRewrite.Core.SimpleList.SimpleList<{design.LastValue.Type}>");
LocalVariable finalResult = CreateGlobalVariable(design, listResultType);
design.ResultAdd(finalResult.Assign(New(listResultType)));
design.ResultAdd(finalResult.Access("Items").Assign(result));
design.ResultAdd(finalResult.Access("Count").Assign(design.ResultSize ?? design.Indexer));
design.ResultAdd(Return(finalResult));
}
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var elementType = design.ReturnType.Type is NullableTypeSyntax nullable
? (TypeBridge)nullable.ElementType : design.ReturnType;
var sumVariable = CreateGlobalVariable(design, elementType, 0);
var value = args.Length switch
{
0 => design.LastValue,
1 => args[0].Inline(design, design.LastValue)
};
if (design.ReturnType.Type is NullableTypeSyntax)
{
value = value.Reusable(design);
design.ForAdd(If(value.NotEqual(null),
sumVariable.AddAssign(value.Cast(elementType))));
}
else
{
design.ForAdd(sumVariable.AddAssign(value));
}
design.ResultAdd(Return(sumVariable));
}
}
public static bool AssertLesser(RewriteDesign design, ValueBridge smaller, ValueBridge bigger, bool initialCheck = true, bool preCheck = false)
{
if (design.Unchecked)
{
return(true);
}
bool biggerPass = ExpressionSimplifier.TryGetDouble(bigger, out double biggerD);
bool smallerPass = ExpressionSimplifier.TryGetDouble(smaller, out double smallerD);
if (biggerPass && smallerPass)
{
if (smallerD < biggerD)
{
return(true);
}
InitialError(design, "System.InvalidOperationException", "Index out of range");
return(false);
}
if (preCheck)
{
return(true);
}
if (initialCheck)
{
design.PreUseAdd(If(smaller >= bigger, Throw("System.InvalidOperationException", "Index out of range")));
}
else
{
design.FinalAdd(If(smaller >= bigger, Throw("System.InvalidOperationException", "Index out of range")));
}
return(true);
}
private static VariableBridge KnownSourceSize(RewriteDesign design, ValueBridge currentLength, VariableBridge resultVariable, int enlarging)
{
var logVariable = CreateGlobalVariable(design, Int,
"LinqRewrite".Access("Core", "IntExtensions", "Log2")
.Invoke(Parenthesize(design.SourceSize).Cast(SyntaxKind.UIntKeyword)) - Constants.MinArraySizeLog);
if (enlarging != 1)
{
design.PreUseAdd(logVariable.Assign(
SyntaxFactory.ConditionalExpression(logVariable.GThan(enlarging),
logVariable - logVariable % enlarging,
IntValue(enlarging))));
}
else
{
design.PreUseAdd(logVariable.Assign(
SyntaxFactory.ConditionalExpression(logVariable.GThan(1),
logVariable,
IntValue(1))));
}
var currentLengthVariable = CreateGlobalVariable(design, Int, currentLength);
design.ForAdd(If(design.Indexer >= currentLengthVariable,
"LinqRewrite".Access("Core", "EnlargeExtensions", "LogEnlargeArray")
.Invoke(enlarging,
design.SourceSize,
RefArg(resultVariable),
RefArg(logVariable),
OutArg(currentLengthVariable))));
design.ForAdd(resultVariable[design.Indexer].Assign(design.LastValue));
return(resultVariable);
}
public static ForStatementSyntax GetReverseForStatement(RewriteDesign design, LocalVariable indexerVariable, ValueBridge min, ValueBridge increment, List <IStatementSyntax> loopContent)
=> ForStatement(
null,
default,
indexerVariable.GeThan(min),
CreateSeparatedExpressionList(indexerVariable.AddAssign(increment)),
GetBody(design, loopContent));
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
design.ForAdd(If(Not(args[0].Inline(design, design.LastValue)),
Return(false)));
design.ResultAdd(Return(true));
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var enlarging = args.FirstOrDefault()?.ToString() switch
{
"EnlargingCoefficient.By2" => 1,
"EnlargingCoefficient.By4" => 2,
"EnlargingCoefficient.By8" => 3,
_ when design.SourceSize != null => 2,
_ => 1
};
var(currentLength, currentResult) = GetResultVariable(design, design.LastValue.Type);
SimplifyPart(design, currentResult);
RewriteOther(design, currentLength, currentResult, enlarging);
if (design.ResultSize == null)
{
design.ResultAdd(Return("LinqRewrite".Access("Core", "SimpleArrayExtensions", "EnsureFullArray")
.Invoke(currentResult, design.Indexer)));
}
else
{
design.ResultAdd(Return(currentResult));
}
}
public static ExpressionSyntax SimpleRewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (args.Length != 0)
{
return(null);
}
return(design.ResultSize.Cast(Long));
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var hashsetType = ParseTypeName($"LinqRewrite.Core.SimpleSet<{design.LastValue.Type}>");
var hashsetVariable = CreateGlobalVariable(design, hashsetType, args.Length switch
{
0 => New(hashsetType),
1 => New(hashsetType, args[0])
});
public static ExpressionSyntax SimpleRewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (args.Length != 0)
{
return(null);
}
return(Substitute(design.LastValue, design.CurrentIterator.ForIndexer, design.CurrentMax));
}
private static VariableBridge KnownSize(RewriteDesign design, VariableBridge resultVariable)
{
if (TryGetInt(design.ResultSize, out var resultInt) && resultInt < 0)
{
InitialErrorAdd(design, Return("System".Access("Array", $"Empty<{design.LastValue.Type}>").Invoke()));
}
design.ForAdd(resultVariable[design.Indexer].Assign(design.LastValue));
return(resultVariable);
}
private static void CalculateSimpleAverage(RewriteDesign design, TypedValueBridge selectionValue, LocalVariable sumVariable)
{
if (!AssertResultSizeGreaterEqual(design, 1))
{
return;
}
design.ForAdd(sumVariable.AddAssign(selectionValue));
design.ResultAdd(Return(sumVariable / design.GetResultSize()));
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args, bool?reuseVariables = null)
{
if (!AssertNotNull(design, design.CurrentCollection))
{
return;
}
design.AddIterator(design.CurrentCollection);
RewriteOther(design, design.CurrentCollection, null, false, reuseVariables);
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
var positionValue = args[0].ReusableConst(design);
design.ForAdd(If(design.Indexer.IsEqual(positionValue),
Return(design.LastValue)));
design.ResultAdd(Return(Default(design.ReturnType)));
}
public static ExpressionSyntax SimpleRewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (args.Length != 0)
{
return(null);
}
return(ConditionalExpression(design.ResultSize.IsEqual(0),
Default(design.ReturnType),
Substitute(design.LastValue, design.CurrentIterator.ForIndexer, design.CurrentMax)));
}
public static ExpressionSyntax SimpleRewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (args.Length != 0)
{
return(null);
}
return(ConditionalExpression(design.ResultSize.IsEqual(1),
Substitute(design.LastValue, design.CurrentIterator.ForIndexer, design.CurrentMin),
ThrowExpression("System.InvalidOperationException", "The sequence does not contain one element.")));
}
public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
{
if (args.Length != 0)
{
design.Indexer = null;
design.ForAdd(If(Not(args[0].Inline(design, design.LastValue)),
Continue()));
}
design.ResultAdd(Return(design.GetIndexer(Long)));
}
private static VariableBridge UnknownSourceSize(RewriteDesign design, ValueBridge currentLength, VariableBridge resultVariable, int enlarging)
{
var currentLengthVariable = CreateGlobalVariable(design, Int, currentLength);
design.ForAdd(If(design.Indexer >= currentLengthVariable,
"LinqRewrite".Access("Core", "EnlargeExtensions", "LogEnlargeArray")
.Invoke(enlarging, RefArg(resultVariable), RefArg(currentLengthVariable))));
design.ForAdd(resultVariable[design.Indexer].Assign(design.LastValue));
return(resultVariable);
}
