Beispiel #1
0
        public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
        {
            var innerValue = args[0];
            RewrittenValueBridge outerKeySelector = args[1];
            RewrittenValueBridge innerKeySelector = args[2];

            if (design.CurrentIterator.IgnoreIterator)
            {
                return;
            }

            var resultSelectorValue = args[3];
            var comparerValue       = args.Length == 5 ? args[4] : null;

            var lookupType     = ParseTypeName($"LinqRewrite.Core.SimpleLookup<{innerValue.ItemType(design)},{innerKeySelector.ReturnType(design)}>");
            var lookupVariable = CreateGlobalVariable(design, lookupType, lookupType.Access("CreateForJoin")
                                                      .Invoke(innerValue, innerKeySelector, comparerValue));

            var itemValue        = design.LastValue;
            var groupingType     = ParseTypeName($"LinqRewrite.Core.SimpleLookup<{innerValue.ItemType(design)},{outerKeySelector.ReturnType(design)}>.Grouping");
            var groupingVariable = CreateGlobalVariable(design, groupingType);

            design.ForAdd(groupingVariable.Assign(lookupVariable.Access("GetGrouping")
                                                  .Invoke(outerKeySelector.Inline(design, itemValue), false)));

            design.ForAdd(If(groupingVariable.IsEqual(null), Continue()));
            var rewritten = new RewrittenValueBridge(((LambdaExpressionSyntax)innerKeySelector.Old).ExpressionBody, groupingVariable);

            var iteratorVariable = CreateGlobalVariable(design, innerKeySelector.ReturnType(design));

            design.IncompleteIterators.ToArray().ForEach(x =>
            {
                var newIterator = new IteratorDesign(design, new CollectionValueBridge(design, groupingType, innerKeySelector.ReturnType(design), rewritten, true));
                x.ForBody.Add(newIterator);
                design.Iterators.Add(newIterator);
                design.Iterators.Remove(x);
                design.CurrentIterator = newIterator;
                RewriteCollectionEnumeration.RewriteOther(design, design.CurrentIterator.Collection, iteratorVariable);
            });

            design.CurrentIterator     = design.Iterators.Last();
            design.LastValue           = resultSelectorValue.Inline(design, itemValue, design.LastValue);
            design.ModifiedEnumeration = true;
            design.ListEnumeration     = false;
            design.SourceSize          = null;
        }
Beispiel #2
0
        public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
        {
            RewrittenValueBridge keySelector = args[0];
            var elementSelectorValue         = args.Length switch
            {
                1 => design.LastValue,
                _ when args[1].OldVal.Invokable1Param(design) => args[1].Inline(design, design.LastValue),
                _ => design.LastValue
            };

            var lookupType     = ParseTypeName($"LinqRewrite.Core.SimpleLookup<{keySelector.ReturnType(design)},{elementSelectorValue.Type}>");
            var lookupVariable = CreateGlobalVariable(design, lookupType, args.Length switch
            {
                2 when !args[1].OldVal.IsInvokable(design) => New(lookupType, args[1]),
                3 when !args[2].OldVal.IsInvokable(design) => New(lookupType, args[2]),
                4 when !args[3].OldVal.IsInvokable(design) => New(lookupType, args[3]),
                _ => New(lookupType, ParseTypeName($"System.Collections.Generic.EqualityComparer<{keySelector.ReturnType(design)}>").Access("Default"))
            });
        public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
        {
            RewrittenValueBridge method = args[0];
            var newExpression           = (LambdaExpressionSyntax)method.NewVal;

            if (design.CurrentIterator.IgnoreIterator)
            {
                return;
            }

            var collectionValue = args.Length switch
            {
                _ when newExpression.Invokable1Param(design) => method.Inline(design, design.LastValue),
                _ => method.Inline(design, design.LastValue, design.Indexer)
            };
            var rewritten = new RewrittenValueBridge(newExpression.ExpressionBody, collectionValue);

            var iteratorVariable = CreateGlobalVariable(design, method.ReturnItemType(design));

            design.IncompleteIterators.ToArray().ForEach(iterator =>
            {
                var newIterator = new IteratorDesign(design, new CollectionValueBridge(design, method.ReturnType(design), method.ReturnItemType(design), rewritten, true));
                iterator.ForBody.Add(newIterator);
                design.Iterators.Add(newIterator);
                design.Iterators.Remove(iterator);
                design.CurrentIterator = newIterator;
                RewriteCollectionEnumeration.RewriteOther(design, design.CurrentIterator.Collection, iteratorVariable);
            });

            design.CurrentIterator = design.Iterators.Last();
            design.LastValue       = args.Length switch
            {
                1 => design.LastValue,
                2 => args[1].Inline(design, design.LastValue, design.Indexer)
            };
            design.ModifiedEnumeration = true;
            design.ListEnumeration     = false;
            design.SourceSize          = null;
        }
    }
}
Beispiel #4
0
        public static void Rewrite(RewriteDesign design, RewrittenValueBridge[] args)
        {
            RewrittenValueBridge inner            = args[0];
            RewrittenValueBridge outerKeySelector = args[1];
            RewrittenValueBridge innerKeySelector = args[2];
            RewrittenValueBridge resultSelector   = args[3];
            RewrittenValueBridge comparer         = args.Length == 5 ? args[4] : null;

            var lookupType     = ParseTypeName($"LinqRewrite.Core.SimpleLookup<{inner.ItemType(design)},{innerKeySelector.ReturnType(design)}>");
            var lookupVariable = CreateGlobalVariable(design, lookupType, lookupType.Access("CreateForJoin")
                                                      .Invoke(inner, innerKeySelector, comparer));

            var lookupItemType = ParseTypeName($"System.Collections.IEnumerable<{inner.ItemType(design)}>");

            design.LastValue = resultSelector.Inline(design, design.LastValue, new TypedValueBridge(lookupItemType, lookupVariable[outerKeySelector.Inline(design, design.LastValue)]));

            design.ListEnumeration     = false;
            design.ModifiedEnumeration = true;
        }