public SlicerResult VisitAssignment(RtlAssignment ass)
{
if (!(ass.Dst is Identifier id))
{
// Ignore writes to memory.
return(null);
}
this.assignLhs = ass.Dst;
var killedRegs = Live.Where(de => de.Key is Identifier i && i.Storage.Domain == id.Storage.Domain).ToList();
if (killedRegs.Count == 0)
{
// This assignment doesn't affect the end result.
return(null);
}
foreach (var killedReg in killedRegs)
{
this.Live.Remove(killedReg.Key);
}
this.assignLhs = killedRegs[0].Key;
var se = ass.Src.Accept(this, killedRegs[0].Value);
if (se == null)
{
return(se);
}
if (se.SrcExpr != null)
{
var newJt = ExpressionReplacer.Replace(assignLhs, se.SrcExpr, JumpTableFormat);
this.JumpTableFormat = slicer.Simplify(newJt);
}
DebugEx.Verbose(BackwardSlicer.trace, " expr: {0}", this.JumpTableFormat);
this.assignLhs = null;
return(se);
}
public async Task <IEnumerable <VegaMoveDeviceData> > GetCurrentAsync(CancellationToken cancellationToken = default)
{
var dataIds = (from data in _context.MoveDeviceDatas
group data by data.DeviceId into gData
select new { gData.Key, date = gData.Max(x => x.Uptime) })
.AsNoTracking();
Expression <Func <VegaMoveDeviceData, bool> > predict = x => false;
foreach (var item in dataIds)
{
Expression <Func <VegaMoveDeviceData, bool> > lambdaNew =
x => x.Uptime == item.date && x.DeviceId == item.Key;
var lambdaBody = ExpressionReplacer
.ReplaceParameter(lambdaNew.Body, lambdaNew.Parameters[0], predict.Parameters[0]);
var body = Expression.OrElse(predict.Body, lambdaBody);
predict = Expression.Lambda <Func <VegaMoveDeviceData, bool> >(body, predict.Parameters);
}
return(await _context.MoveDeviceDatas
.Where(predict)
.AsNoTracking()
.ToListAsync(cancellationToken)
.ConfigureAwait(false));
}
internal void Compile(params object[] args)
{
if (this.fnQuery == null)
{
// first identify the query provider being used
Expression body = this.query.Body;
ConstantExpression root = RootQueryableFinder.Find(body) as ConstantExpression;
if (root == null && args != null && args.Length > 0)
{
Expression replaced = ExpressionReplacer.ReplaceAll(
body,
this.query.Parameters.ToArray(),
args.Select((a, i) => Expression.Constant(a, this.query.Parameters[i].Type)).ToArray()
);
body = PartialEvaluator.Eval(replaced);
root = RootQueryableFinder.Find(body) as ConstantExpression;
}
if (root == null)
{
throw new InvalidOperationException("Could not find query provider");
}
// ask the query provider to compile the query by 'executing' the lambda expression
IQueryProvider provider = ((IQueryable)root.Value).Provider;
Delegate result = (Delegate)provider.Execute(this.query);
System.Threading.Interlocked.CompareExchange(ref this.fnQuery, result, null);
}
}
public static Expression ExtractLoopInvariantFatExpressions(this Expression expression, IEnumerable <ParameterExpression> invariantParameters, Func <Expression, Expression> resultSelector)
{
var extractedExpressions = new InvariantCodeExtractor(invariantParameters).Extract(expression);
if (extractedExpressions.Length == 0)
{
return(resultSelector(expression));
}
var aliases = new Dictionary <Expression, Expression>();
var variables = new List <ParameterExpression>();
foreach (var exp in extractedExpressions)
{
if (!aliases.ContainsKey(exp))
{
var variable = Expression.Variable(exp.Type);
variables.Add(variable);
aliases.Add(exp, variable);
}
}
var optimizedExpression = new ExpressionReplacer(aliases).Visit(expression);
return(Expression.Block(variables, aliases.Select(pair => Expression.Assign(pair.Value, pair.Key)).Concat(new[] { resultSelector(optimizedExpression) })));
}
private static Expression Complex(this LambdaExpression current, LambdaExpression other, Func <Expression, Expression, Expression> func)
{
if (current == null && other == null)
{
return(null);
}
if (other == null)
{
return(current);
}
if (current == null)
{
return(other);
}
if (current.Parameters.Count != other.Parameters.Count)
{
return(null);
}
var pars = current.Parameters;
var left = current.Body;
var right = other.Body;
right = ExpressionReplacer.Replace(right, pars);
return(func(left, right));
}
/// <summary>
/// Bind parameter expressions to <see cref="LambdaExpression"/>.
/// </summary>
/// <param name="lambdaExpression"><see cref="LambdaExpression"/> to bind parameters.</param>
/// <param name="parameters"><see cref="Expression"/>s to bind to <paramref name="lambdaExpression"/></param>
/// <returns>Body of <paramref name="lambdaExpression"/> with lambda's parameters replaced
/// with corresponding expression from <paramref name="parameters"/></returns>
/// <exception cref="InvalidOperationException">Something went wrong :(.</exception>
public static Expression BindParameters(this LambdaExpression lambdaExpression, params Expression[] parameters)
{
if (lambdaExpression.Parameters.Count != parameters.Length)
{
throw new InvalidOperationException(String.Format(
Strings.ExUnableToBindParametersToLambdaXParametersCountIsIncorrect,
lambdaExpression.ToString(true)));
}
if (parameters.Length == 0)
{
return(lambdaExpression);
}
var convertedParameters = new Expression[parameters.Length];
for (int i = 0; i < lambdaExpression.Parameters.Count; i++)
{
var expressionParameter = lambdaExpression.Parameters[i];
if (expressionParameter.Type.IsAssignableFrom(parameters[i].Type))
{
convertedParameters[i] = expressionParameter.Type == parameters[i].Type
? parameters[i]
: Expression.Convert(parameters[i], expressionParameter.Type);
}
else
{
throw new InvalidOperationException(String.Format(
Strings.ExUnableToUseExpressionXAsXParameterOfLambdaXBecauseOfTypeMistmatch,
parameters[i].ToString(true), i, lambdaExpression.Parameters[i].ToString(true)));
}
}
return(ExpressionReplacer.ReplaceAll(
lambdaExpression.Body, lambdaExpression.Parameters, convertedParameters));
}
private static TExpr ReplaceExpressions <TExpr>(TExpr expression, Expression orig, Expression replacement)
where TExpr : Expression
{
var replacer = new ExpressionReplacer(orig, replacement);
return(replacer.VisitAndConvert(expression, nameof(ReplaceExpressions)));
}
public void Test007()
{
var builder = ExpressionReplacer.Search(GenericExpressionToSearchIn());
builder.When(GenericExpressionToSearchFor(), GenericExpressionToReplaceWith());
builder.ReplaceIn(GenericExpressionToSearchIn());
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var obj = base.Visit(node.Object);
var args = base.Visit(node.Arguments);
LambdaExpression?lambda = ExpressionCleaner.GetFieldExpansion(obj?.Type, node.Method);
if (lambda != null)
{
var replace = ExpressionReplacer.Replace(Expression.Invoke(lambda, obj == null ? args : args.PreAnd(obj)));
return(this.Visit(replace));
}
if (node.Method.Name == "ToString" && node.Arguments.IsEmpty() && obj is CachedEntityExpression ce)
{
var table = (Table)ce.Constructor.table;
if (table.ToStrColumn == null)
{
throw new InvalidOperationException("Impossible to get ToStrColumn from " + ce.ToString());
}
return(BindMember(ce, (FieldValue)table.ToStrColumn, null));
}
return(node.Update(obj, args));
}
public static Expression Replace(InvocationExpression invocation)
{
LambdaExpression lambda = (LambdaExpression)invocation.Expression;
var replacer = new ExpressionReplacer(0.To(lambda.Parameters.Count).ToDictionaryEx(i => lambda.Parameters[i], i => invocation.Arguments[i]));
return(replacer.Visit(lambda.Body));
}
public static Expression Replace(Expression expression, ParameterExpression searchExp, ParameterExpression replaceExp)
{
var replacer = new ExpressionReplacer {
searchExp = searchExp, replaceExp = replaceExp
};
return(replacer.Visit(expression));
}
public void Test001()
{
ExpressionReplacer.Replace(
GenericExpressionToSearchIn(),
GenericExpressionToSearchFor(),
GenericExpressionToReplaceWith()
);
}
private static LambdaExpression Compose(LambdaExpression first, LambdaExpression second)
{
var body = ExpressionReplacer.Replace(second.Body,
second.Parameters [0],
first.Body);
return(Expression.Lambda(body, first.Parameters [0]));
}
protected static Expression ModifyExpressionAndReturnResult(Expression expression, IQueryable queryableEntities, MethodCallExpression expressionToReplace, MethodInfo replacingMethod)
{
var replacingExpression = GetReplacingExpression(expressionToReplace, queryableEntities, replacingMethod);
var treeModifier = new ExpressionReplacer(expressionToReplace, replacingExpression);
return(treeModifier.Visit(expression));
}
//internal static Expression JustVisit(LambdaExpression expression, PropertyRoute route)
//{
// if (route.Type.IsLite())
// route = route.Add("Entity");
// return JustVisit(expression, ));
//}
internal static Expression JustVisit(LambdaExpression expression, MetaExpression metaExpression)
{
var cleaned = MetaEvaluator.Clean(expression);
var replaced = ExpressionReplacer.Replace(Expression.Invoke(cleaned, metaExpression));
return(new MetadataVisitor().Visit(replaced));
}
public void Test001()
{
var xgr = new ExpressionGenerator();
var e1 = xgr.MultiProject(
() => new {
FieldOne = 1,
FieldTwo = "ABC"
},
x => new InitializerOne {
IntField = x.FieldOne,
StringField = x.FieldTwo
},
_initializerOneTemplate,
x => new InitializerTwo {
StringFieldOne = x.FieldTwo + "DEF",
StringFieldTwo = "GHI" + x.FieldTwo
},
_initializerTwoTemplate,
(x, y) => new {
InitializerOneResult = x,
InitializerTwoResult = y
}
);
var inputPlaceholder = xgr.FromFunc(() => new {
FieldOne = 1,
FieldTwo = "ABC"
});
var expectations = xgr.FromFunc(inputPlaceholder, x => new {
InitializerOneResult = (new InitializerOne {
IntField = x.FieldOne,
StringField = x.FieldTwo
}).StringField + (new InitializerOne
{
IntField = x.FieldOne,
StringField = x.FieldTwo
}).IntField,
InitializerTwoResult = (new InitializerTwo {
StringFieldOne = x.FieldTwo + "DEF",
StringFieldTwo = "GHI" + x.FieldTwo
}).StringFieldTwo + (new InitializerTwo
{
StringFieldOne = x.FieldTwo + "DEF",
StringFieldTwo = "GHI" + x.FieldTwo
}).StringFieldOne
});
var inputParam = Expression.Parameter(inputPlaceholder.ReturnType);
var expected = Expression.Lambda(
ExpressionReplacer.Replace(expectations.Body, inputPlaceholder.Body, inputParam),
inputParam
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, e1));
}
private static TContainer DoArrange <TContainer>(object obj, Type objType, LambdaExpression expression, Func <TContainer> containerFactory) where TContainer : IMethodMock
{
var repo = MockingContext.CurrentRepository;
var instanceParam = expression.Parameters[0];
var instanceConstant = Expression.Constant(obj);
var parameterlessBody = ExpressionReplacer.Replace(expression.Body, instanceParam, instanceConstant);
var parameterlessArrangeStmt = Expression.Lambda(parameterlessBody);
return(repo.Arrange(parameterlessArrangeStmt, containerFactory));
}
public void Test014()
{
var builder = ExpressionReplacer.PrepareSearch();
try { builder.GetResult(); Assert.Fail("Test should not reach here"); }
catch (NullReferenceException eError)
{
Assert.AreEqual("no target, perhaps you want ReplaceIn() instead", eError.Message);
}
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.DeclaringType == typeof(string) && node.Method.Name == nameof(string.Format) ||
node.Method.DeclaringType == typeof(StringExtensions) && node.Method.Name == nameof(StringExtensions.FormatWith))
{
var formatStr = Visit(node.Arguments[0]);
var remainging = node.Arguments.Skip(1).Select(a => Visit(ToString(a))).ToList();
return(node.Update(null, new Sequence <Expression> {
formatStr, remainging
}));
}
var obj = base.Visit(node.Object);
var args = base.Visit(node.Arguments);
if (node.Method.Name == "ToString" && node.Arguments.IsEmpty() && obj is CachedEntityExpression ce && ce.Type.IsEntity())
{
var table = (Table)ce.Constructor.table;
if (table.ToStrColumn != null)
{
return(BindMember(ce, (FieldValue)table.ToStrColumn, null));
}
else if (this.root != ce)
{
var cachedTableType = typeof(CachedTable <>).MakeGenericType(table.Type);
ConstantExpression tab = Expression.Constant(ce.Constructor.cachedTable, cachedTableType);
var mi = cachedTableType.GetMethod(nameof(CachedTable <Entity> .GetToString));
return(Expression.Call(tab, mi, ce.PrimaryKey.UnNullify()));
}
}
LambdaExpression?lambda = ExpressionCleaner.GetFieldExpansion(obj?.Type, node.Method);
if (lambda != null)
{
var replace = ExpressionReplacer.Replace(Expression.Invoke(lambda, obj == null ? args : args.PreAnd(obj)));
return(this.Visit(replace));
}
if (node.Method.Name == nameof(Entity.Mixin) && obj is CachedEntityExpression cee)
{
var mixin = ((Table)cee.Constructor.table).GetField(node.Method);
return(GetField(mixin, cee.Constructor, cee.PrimaryKey));
}
return(node.Update(obj, args));
}
protected override Expression VisitInvocation(InvocationExpression iv)
{
if (iv.Expression is LambdaExpression)
{
return(Visit(ExpressionReplacer.Replace(iv)));
}
else
{
return(base.VisitInvocation(iv)); //Just calling a delegate in the projector
}
}
private MappingEntry CreateMappingEntry(Expression expression)
{
var tupleAccess = expression.StripCasts().AsTupleAccess();
if (tupleAccess != null)
{
return(new MappingEntry(tupleAccess.GetTupleAccessArgument()));
}
expression = ExpressionReplacer.Replace(expression, filterDataTuple, calculatedColumnParameter);
return(new MappingEntry(FastExpression.Lambda(expression, calculatedColumnParameter)));
}
public static Expression <Func <T, bool> > AddWithAnd <T>(this Expression <Func <T, bool> > expr1, Expression <Func <T, bool> > expr2)
{
if (expr1 == null)
{
return(expr2);
}
var replacer = new ExpressionReplacer(CreateFromToReplaceSet(expr2.Parameters, expr1.Parameters), null, null, null, null);
var rightExpression = (LambdaExpression)replacer.HandleExpression(expr2);
return(Expression.Lambda <Func <T, bool> >
(Expression.AndAlso(expr1.Body, rightExpression.Body), expr1.Parameters));
}
private static void GetGeneralMemberBindings(object obj, Type sourceType, Type conversionType, ParameterExpression parExp, List <MemberBinding> bindings, ConvertMapper mapper)
{
var lazyMgr = obj as ILazyManager;
foreach (var property in conversionType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
try
{
if (lazyMgr != null && !lazyMgr.IsValueCreated(property.Name))
{
continue;
}
Expression descExp = null;
//在映射器里查找转换表达式
if (mapper != null)
{
descExp = mapper.GetMapExpression(property);
if (descExp != null)
{
descExp = (ExpressionReplacer.Replace(descExp, parExp) as LambdaExpression).Body;
}
}
if (descExp == null)
{
var sourceProperty = sourceType.GetProperty(property.Name, BindingFlags.Public | BindingFlags.Instance);
if (sourceProperty == null || !sourceProperty.CanRead || !property.CanWrite)
{
continue;
}
descExp = Expression.MakeMemberAccess(parExp, sourceProperty);
if (property.PropertyType != sourceProperty.PropertyType)
{
descExp = Expression.Call(null, MthToType,
Expression.Convert(descExp, typeof(object)),
Expression.Constant(property.PropertyType),
Expression.Constant(null),
Expression.Constant(null, typeof(ConvertMapper)));
descExp = Expression.Convert(descExp, property.PropertyType);
}
}
bindings.Add(Expression.Bind(property, descExp));
}
catch
{
continue;
}
}
}
public static void ApplyFunctionalSpec <T>(T mock, Expression <Func <T, bool> > specExpr, IReturnArranger arranger)
{
try
{
var body = ExpressionReplacer.Replace(specExpr.Body, specExpr.Parameters[0], Expression.Constant(mock, typeof(T)));
ApplySpecExpression(body, arranger);
}
catch (InvalidCastException ex)
{
throw new MockException("Incorrect functional spec expression format.", ex);
}
}
public static Expression <Func <T, bool> > MakePropertiesPredicate <T, TValue>(Expression <Func <TValue, TValue, bool> > pattern, TValue searchValue, bool isOr)
{
var parameter = Expression.Parameter(typeof(T), "e");
var searchExpr = Expression.Constant(searchValue);
var predicateBody = typeof(T).GetProperties()
.Where(p => p.PropertyType == typeof(TValue))
.Select(p =>
ExpressionReplacer.GetBody(pattern, Expression.MakeMemberAccess(
parameter, p), searchExpr))
.Aggregate(isOr ? Expression.OrElse : Expression.AndAlso);
return(Expression.Lambda <Func <T, bool> >(predicateBody, parameter));
}
private static void DoAssert(object obj, Type objType, LambdaExpression expression, Args args, Occurs occurs)
{
var repo = MockingContext.CurrentRepository;
Expression parameterlessArrangeStmt = null;
if (expression != null)
{
var instanceParam = expression.Parameters[0];
var instanceConstant = Expression.Constant(obj);
var parameterlessBody = ExpressionReplacer.Replace(expression.Body, instanceParam, instanceConstant);
parameterlessArrangeStmt = Expression.Lambda(parameterlessBody);
}
repo.Assert(obj, parameterlessArrangeStmt, args, occurs);
}
public static TExpression Replace <TExpression>(
this TExpression expression,
Dictionary <Expression, Expression> replacementsByTarget)
where TExpression : Expression
{
if (replacementsByTarget.None())
{
return(expression);
}
var replacer = new ExpressionReplacer(replacementsByTarget);
var replaced = replacer.ReplaceIn(expression);
return((TExpression)replaced);
}
public void AssociateWith(LambdaExpression memberQuery)
{
MemberExpression searchFor = RootMemberFinder.Find(memberQuery, memberQuery.Parameters[0]);
if (searchFor == null)
{
throw new InvalidOperationException("Subquery does not originate with a member access");
}
if (searchFor != memberQuery.Body)
{
ParameterExpression replaceWith = Expression.Parameter(searchFor.Type, "root");
Expression body = ExpressionReplacer.Replace(memberQuery.Body, searchFor, replaceWith);
this.AddOperation(searchFor.Member, Expression.Lambda(body, new ParameterExpression[] { replaceWith }));
}
}
public void AssociateWith(LambdaExpression memberQuery)
{
var rootMember = RootMemberFinder.Find(memberQuery, memberQuery.Parameters[0]);
if (rootMember == null)
{
throw new InvalidOperationException("Subquery does not originate with a member access");
}
if (rootMember != memberQuery.Body)
{
var memberParam = Expression.Parameter(rootMember.Type, "root");
var newBody = ExpressionReplacer.Replace(memberQuery.Body, rootMember, memberParam);
this.AddOperation(rootMember.Member, Expression.Lambda(newBody, memberParam));
}
}
/// <summary>
/// 在 Select 中应用 <see cref="ExtendAs{T}(IEntity, Expression{Func{object}})"/> 来扩展返回的结果。
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="selector"></param>
/// <returns></returns>
public static IQueryable <TResult> ExtendSelect <TSource, TResult>(this IQueryable <TSource> source, Expression <Func <TSource, TResult> > selector)
{
var parExp = Expression.Parameter(typeof(TSource), "t");
var method = typeof(Extensions).GetMethod(nameof(Extensions.ExtendAs)).MakeGenericMethod(typeof(TResult));
var newExp = ExpressionReplacer.Replace(selector.Body, parExp);
var newSelector = Expression.Lambda <Func <object> >(newExp);
var callExp = Expression.Call(null, method, parExp, newSelector);
var lambda = Expression.Lambda(callExp, parExp);
var expression = Expression.Call(typeof(Queryable), nameof(Queryable.Select), new[] { typeof(TSource), typeof(TResult) }, source.Expression, lambda);
return(source.Provider.CreateQuery <TResult>(expression));
}
