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