public static MemberInfo ToProperty(this LambdaExpression expr)
{
var expression = expr.Body;
var unaryExpression = expression as UnaryExpression;
if (unaryExpression != null)
{
switch (unaryExpression.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
expression = unaryExpression.Operand;
break;
}
}
var me = expression as MemberExpression;
if (me == null)
{
throw new InvalidOperationException("No idea how to convert " + expr.Body.NodeType + ", " + expr.Body +
" to a member expression");
}
return(me.Member);
}
/// <summary>
/// Analyzes a lambda expression to check whether it can be satisfied with
/// $select and client-side materialization.
/// </summary>
/// <param name="le">Lambda expression.</param>
/// <param name="re">Resource expression in scope.</param>
/// <param name="matchMembers">Whether member accesses are matched as top-level projections.</param>
/// <returns>true if the lambda is a client-side projection; false otherwise.</returns>
internal static bool Analyze(LambdaExpression le, ResourceExpression re, bool matchMembers)
{
Debug.Assert(le != null, "le != null");
if (le.Body.NodeType == ExpressionType.Constant)
{
if (ClientType.CheckElementTypeIsEntity(le.Body.Type))
{
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
}
re.Projection = new ProjectionQueryOptionExpression(le.Body.Type, le, new List<string>());
return true;
}
if (le.Body.NodeType == ExpressionType.MemberInit || le.Body.NodeType == ExpressionType.New)
{
AnalyzeResourceExpression(le, re);
return true;
}
if (matchMembers)
{
// Members can be projected standalone or type-casted.
Expression withoutConverts = SkipConverts(le.Body);
if (withoutConverts.NodeType == ExpressionType.MemberAccess)
{
AnalyzeResourceExpression(le, re);
return true;
}
}
return false;
}
public GroupJoinExpressionNode (
MethodCallExpressionParseInfo parseInfo,
Expression innerSequence,
LambdaExpression outerKeySelector,
LambdaExpression innerKeySelector,
LambdaExpression resultSelector)
: base(parseInfo)
{
ArgumentUtility.CheckNotNull ("innerSequence", innerSequence);
ArgumentUtility.CheckNotNull ("outerKeySelector", outerKeySelector);
ArgumentUtility.CheckNotNull ("innerKeySelector", innerKeySelector);
ArgumentUtility.CheckNotNull ("resultSelector", resultSelector);
if (outerKeySelector.Parameters.Count != 1)
throw new ArgumentException ("Outer key selector must have exactly one parameter.", "outerKeySelector");
if (innerKeySelector.Parameters.Count != 1)
throw new ArgumentException ("Inner key selector must have exactly one parameter.", "innerKeySelector");
if (resultSelector.Parameters.Count != 2)
throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector");
var joinResultSelector = Expression.Lambda (Expression.Constant (null), outerKeySelector.Parameters[0], innerKeySelector.Parameters[0]);
JoinExpressionNode = new JoinExpressionNode (parseInfo, innerSequence, outerKeySelector, innerKeySelector, joinResultSelector);
ResultSelector = resultSelector;
_cachedResultSelector = new ResolvedExpressionCache<Expression> (this);
}
public ThenIncludeExpressionNode(
MethodCallExpressionParseInfo parseInfo,
[NotNull] LambdaExpression navigationPropertyPathLambda)
: base(parseInfo, null, null)
{
_navigationPropertyPathLambda = navigationPropertyPathLambda;
}
/**
* приводит лямбду (x, y, ...) => ... к виду: (x, y, ...) => fn(p, q, ...)
* где fn - оптимизированная лямбда, p, q - предварительно вычисленные выражения
*
* пример:
* Func<int, int, Func<int, int, int, int>, int> fn = (int x, int y, Func<int, int, int, int> Foo) => Foo(F(x), F(y), F(2 * y));
* Func<int, int, int> optimizedLambda = (int x, int y) => fn(1, 2, (int p, int q, int l) => p > q ? p : (p < l ? l : q));
*/
public Expression Optimize(LambdaExpression lambda, string functionName)
{
if (_methodCalls != null)
_methodCalls.Clear();
else
_methodCalls = new Dictionary<string, MethodCall>();
_innerLambdaParams = new List<Expression>();
_functionName = functionName;
// получаем оптимизированную лямбду
Expression fn = BuildInnerLambda(lambda);
// копируем параметры для новой лямбды
ParameterExpression[] parameters = new ParameterExpression[lambda.Parameters.Count];
lambda.Parameters.CopyTo(parameters, 0);
// собираем новую лямбду
Expression optimizedLambda = Expression.Lambda(
Expression.Invoke(fn, _innerLambdaParams),
parameters
);
return optimizedLambda;
}
public override Expression GetUpdateExpression(IMappedEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector)
{
var IdentifiableAlias = new IdentifiableAlias();
var table = new IdentifiableExpression(IdentifiableAlias, entity, ((OTypeMapping)this.Mapping).GetTableName(entity));
var where = this.GetIdentityCheck(table, entity, instance);
if (updateCheck != null)
{
Expression typeProjector = this.GetEntityExpression(table, entity);
Expression pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector);
where = where.And(pred);
}
var assignments = this.GetFieldAssignments(table, instance, entity, (e, m) => ((OTypeMapping)this.Mapping).IsUpdatable(e, m));
Expression update = new UpdateCommandExpression(table, where, assignments);
if (selector != null)
{
return CreateUpdateCommand(entity, instance, selector, where, assignments);
}
else
{
return update;
}
}
public static PropertyInfo FindProperty(LambdaExpression lambdaExpression)
{
Expression expressionToCheck = lambdaExpression;
bool done = false;
while (!done)
{
switch (expressionToCheck.NodeType)
{
case ExpressionType.Convert:
expressionToCheck = ((UnaryExpression) expressionToCheck).Operand;
break;
case ExpressionType.Lambda:
expressionToCheck = lambdaExpression.Body;
break;
case ExpressionType.MemberAccess:
var propertyInfo = ((MemberExpression) expressionToCheck).Member as PropertyInfo;
return propertyInfo;
default:
done = true;
break;
}
}
return null;
}
public static Expression ReplaceParameters(LambdaExpression @in, IEnumerable<Expression> with)
{
Expression e = @in.Body;
var withList = with.ToList();
if (withList.Count() == @in.Parameters.Count)
{
e = @in.Parameters.Zip(withList, (parameter, replace) => new {parameter, replace})
.Aggregate(e, (current, expression) => Rewrite(current, expression.parameter, expression.replace));
}
else
{
foreach (var parameter in @in.Parameters)
{
ParameterExpression parameter1 = parameter;
foreach (var withParameter in withList.Where(withParameter => parameter1.Type == withParameter.Type))
{
e = Rewrite(e, parameter, withParameter);
break;
}
}
}
return e;
}
public void Inspect(LambdaExpression keysExpression, bool direction)
{
foreach (var columnMap in MapTransformer.Transform(keysExpression, queryBlock.QueryMap))
{
keyMap.Add(new ColumnMapAndDesc(columnMap, direction));
}
}
private static Func<ExpressionIterationNode, bool> ParsePattern(LambdaExpression pattern)
{
//foreach (var node in pattern.Iterate())
//{
//}
}
public override bool IsValid(LambdaExpression expr)
{
// expression should be binary expresion
if (!(expr.Body is BinaryExpression))
{
return false;
}
var body = expr.Body as BinaryExpression;
// // left operand should be binary expression
// if (!(body.Left is BinaryExpression))
// {
// return false;
// }
//
// // right operand should be binary expression
// if (!(body.Right is BinaryExpression))
// {
// return false;
// }
var lambdaParam = expr.Parameters[0];
// check left operand
if (!this.isExpressionValid(body.Left, lambdaParam))
{
return false;
}
// check right operand
if (!this.isExpressionValid(body.Right, lambdaParam))
{
return false;
}
return true;
}
public SelectManyExpressionNode (
MethodCallExpressionParseInfo parseInfo, LambdaExpression collectionSelector, LambdaExpression resultSelector)
: base (parseInfo)
{
ArgumentUtility.CheckNotNull ("collectionSelector", collectionSelector);
if (collectionSelector.Parameters.Count != 1)
throw new ArgumentException ("Collection selector must have exactly one parameter.", "collectionSelector");
CollectionSelector = collectionSelector;
if (resultSelector != null)
{
if (resultSelector.Parameters.Count != 2)
throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector");
ResultSelector = resultSelector;
}
else
{
var parameter1 = Expression.Parameter (collectionSelector.Parameters[0].Type, collectionSelector.Parameters[0].Name);
var itemType = ReflectionUtility.GetItemTypeOfClosedGenericIEnumerable (CollectionSelector.Body.Type, "collectionSelector");
var parameter2 = Expression.Parameter (itemType, parseInfo.AssociatedIdentifier);
ResultSelector = Expression.Lambda (parameter2, parameter1, parameter2);
}
_cachedCollectionSelector = new ResolvedExpressionCache<Expression> (this);
_cachedResultSelector = new ResolvedExpressionCache<Expression> (this);
}
internal DynamicFilterDefinition(string filterName, LambdaExpression predicate, string columnName, Type clrType)
{
FilterName = filterName;
Predicate = predicate;
ColumnName = columnName;
_CLRType = clrType;
}
/// <summary>
/// Transforms a LambdaExpression to a debuggable LambdaExpression
/// </summary>
public MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda, DebugLambdaInfo lambdaInfo)
{
ContractUtils.RequiresNotNull(lambda, "lambda");
ContractUtils.RequiresNotNull(lambdaInfo, "lambdaInfo");
return(new DebuggableLambdaBuilder(this, lambdaInfo).Transform(lambda));
}
/// <summary>
/// Gets the name of the member used in the <paramref name="expression"/>.
/// </summary>
/// <param name="expression">
/// The <see cref="T:LambdaExpression"/> that calls the class member
/// whose name should be returned.
/// </param>
/// <returns>
/// The name of the member used in the <paramref name="expression"/>.
/// </returns>
public virtual string GetMemberName(LambdaExpression expression) {
if (null == expression) throw new ArgumentNullException("expression");
var body = expression.Body;
if (body != null) {
var try1 = body as UnaryExpression;
if (try1 != null) {
var try11 = try1.Operand as MemberExpression;
if (try11 != null) {
return GetMemberName(try11);
}
var try12 = try1.Operand as MethodCallExpression;
if (try12 != null) {
return GetMemberName(try12);
}
}
var try2 = body as MemberExpression;
if (try2 != null) {
return GetMemberName(try2);
}
var try3 = body as MethodCallExpression;
if (try3 != null) {
return GetMemberName(try3);
}
}
throw new InvalidTargetMemberException(expression);
}
public override IQueryBuilderRecord Process(LambdaExpression expression)
{
if (!StartsWithParameterReference(expression.Body))
CannotOptimize(expression.Body);
return ApplyDirection(base.Process(expression));
}
// Terminology used in this file:
//
// - a "statement" is something like "x.Foo? AS Bar"
// - "text" is a collection of statements, like "x.Foo? AS Bar, y.Baz as Qak"
public static ReturnExpression BuildText(LambdaExpression expression, bool camelCaseProperties)
{
var body = expression.Body;
if (body.NodeType == ExpressionType.Convert &&
body is UnaryExpression)
{
body = ((UnaryExpression)expression.Body).Operand;
}
string text;
switch (body.NodeType)
{
case ExpressionType.MemberInit:
var memberInitExpression = (MemberInitExpression) body;
text = BuildText(memberInitExpression, camelCaseProperties);
return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection};
case ExpressionType.New:
var newExpression = (NewExpression) body;
text = BuildText(newExpression,camelCaseProperties);
return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection};
case ExpressionType.Call:
var methodCallExpression = (MethodCallExpression) body;
text = BuildText(methodCallExpression);
return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Set};
case ExpressionType.MemberAccess:
var memberExpression = (MemberExpression) body;
text = BuildText(memberExpression, camelCaseProperties);
return new ReturnExpression { Text = text, ResultMode = CypherResultMode.Set };
default:
throw new ArgumentException(WithExpressionShouldBeOneOfExceptionMessage, "expression");
}
}
protected FetchExpressionNodeBase (MethodCallExpressionParseInfo parseInfo, LambdaExpression relatedObjectSelector)
: base (parseInfo, null, null)
{
ArgumentUtility.CheckNotNull ("relatedObjectSelector", relatedObjectSelector);
var memberExpression = relatedObjectSelector.Body as MemberExpression;
if (memberExpression == null)
{
var message = string.Format (
"A fetch request must be a simple member access expression; '{0}' is a {1} instead.",
relatedObjectSelector.Body,
relatedObjectSelector.Body.GetType ().Name);
throw new ArgumentException (message, "relatedObjectSelector");
}
var owner = StripConverts (memberExpression.Expression);
if (owner.NodeType != ExpressionType.Parameter)
{
var message = string.Format (
"A fetch request must be a simple member access expression of the kind o => o.Related; '{0}' is too complex.",
relatedObjectSelector.Body);
throw new ArgumentException (message, "relatedObjectSelector");
}
RelationMember = memberExpression.Member;
}
public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count < 2)
{
return base.GetDeleteExpression(entity, instance, deleteCheck);
}
var commands = new List<Expression>();
foreach (var table in this.GetDependencyOrderedTables(entity).Reverse())
{
TableExpression tex = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(table));
var where = this.GetIdentityCheck(tex, entity, instance);
commands.Add(new DeleteCommand(tex, where));
}
Expression block = new BlockCommand(commands);
if (deleteCheck != null)
{
var test = this.GetEntityStateTest(entity, instance, deleteCheck);
return new IFCommand(test, block, null);
}
return block;
}
public ExpressionsPrinter(LambdaExpression expression)
{
Contract.Requires(expression != null, "expression should not be null.");
_stringParameters = EvaluateParameters(expression.Parameters);
_stringBody = EvaluateBody(expression.Body);
}
private Expression ConvertLambda(LinqExp.LambdaExpression linqLambda)
{
return(Expression.Lambda(
linqLambda.Type,
ConvertExp(linqLambda.Body),
linqLambda.Parameters.Project(Convert)));
}
public static IEnumerable<Expression> Match(this LambdaExpression expression, LambdaExpression pattern)
{
//var patternSequence = pattern.Body.Iterate().ToList();
//if (patternSequence.Count == 0)
//{
// throw new ArgumentException("Invalid pattern", "pattern");
//}
//var rootNode = patternSequence[0];
//var partialMatches = new List<PartialMatch>();
//foreach (var node in expression.Iterate())
//{
// partialMatches.Add(new PartialMatch { Root = node });
// for (var i = partialMatches.Count - 1; i >= 0; --i)
// {
// var partialMatch = partialMatches[i];
// if (Matches(node, patternSequence[partialMatch.Position]))
// {
// partialMatch.Position++;
// if (partialMatch.Position < patternSequence.Count)
// {
// continue;
// }
// yield return (Expression)partialMatch.Root.Element;
// }
// partialMatches.RemoveAt(i);
// }
//}
}
internal MSAst.LambdaExpression Transform(MSAst.LambdaExpression lambda)
{
if (_alias == null)
{
_alias = lambda.Name;
if (_alias == null)
{
_alias = "$lambda" + ++_lambdaId;
}
}
// Create lambda builders
_lambdaVars = new List <MSAst.ParameterExpression>();
_lambdaParams = new List <MSAst.ParameterExpression>();
_generatorVars = new List <MSAst.ParameterExpression>();
_generatorParams = new List <MSAst.ParameterExpression>();
if (lambda.Body is GeneratorExpression)
{
return(TransformGenerator(lambda));
}
else
{
return(TransformLambda(lambda));
}
}
public JoinExpressionNode(
MethodCallExpressionParseInfo parseInfo,
Expression innerSequence,
LambdaExpression outerKeySelector,
LambdaExpression innerKeySelector,
LambdaExpression resultSelector)
: base(parseInfo)
{
ArgumentUtility.CheckNotNull ("innerSequence", innerSequence);
ArgumentUtility.CheckNotNull ("outerKeySelector", outerKeySelector);
ArgumentUtility.CheckNotNull ("innerKeySelector", innerKeySelector);
ArgumentUtility.CheckNotNull ("resultSelector", resultSelector);
if (outerKeySelector.Parameters.Count != 1)
throw new ArgumentException ("Outer key selector must have exactly one parameter.", "outerKeySelector");
if (innerKeySelector.Parameters.Count != 1)
throw new ArgumentException ("Inner key selector must have exactly one parameter.", "innerKeySelector");
if (resultSelector.Parameters.Count != 2)
throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector");
InnerSequence = innerSequence;
OuterKeySelector = outerKeySelector;
InnerKeySelector = innerKeySelector;
ResultSelector = resultSelector;
_cachedOuterKeySelector = new ResolvedExpressionCache<Expression> (this);
_cachedInnerKeySelector = new ResolvedExpressionCache<Expression> (this);
_cachedResultSelector = new ResolvedExpressionCache<Expression> (this);
}
private void CreateFunctionInfo(MSAst.LambdaExpression generatorFactoryLambda)
{
if (_lambdaInfo.CompilerSupport != null && _lambdaInfo.CompilerSupport.DoesExpressionNeedReduction(generatorFactoryLambda))
{
_functionInfo = _lambdaInfo.CompilerSupport.QueueExpressionForReduction(
Ast.Call(
typeof(RuntimeOps).GetMethod("CreateFunctionInfo"),
generatorFactoryLambda,
AstUtils.Constant(_alias),
AstUtils.Constant(_debugMarkerLocationMap, typeof(object)),
AstUtils.Constant(_variableScopeMap, typeof(object)),
AstUtils.Constant(_variableInfos, typeof(object)),
Ast.Constant(_lambdaInfo.CustomPayload, typeof(object))
)
);
}
else
{
_functionInfo = Ast.Constant(
DebugContext.CreateFunctionInfo(
generatorFactoryLambda.Compile(),
_alias,
_debugMarkerLocationMap,
_variableScopeMap,
_variableInfos,
_lambdaInfo.CustomPayload),
typeof(FunctionInfo));
}
}
private static string ExtractMemberName(LambdaExpression expr)
{
var body = expr.Body;
var parts = new List<string>();
for(;;)
{
switch(body.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
body = ((UnaryExpression)body).Operand;
break;
case ExpressionType.MemberAccess:
var member = ((MemberExpression)body).Member;
if(!member.DeclaringType.IsDefined(typeof(CompilerGeneratedAttribute), true))
// Don't add access to compiler-generated classes to our path because an expression such as () => command.Member.SubMember will contain an access to the "command" member of an anonymous type.
{
parts.Add(member.Name);
}
body = ((MemberExpression)body).Expression;
break;
case ExpressionType.Constant:
case ExpressionType.Parameter:
goto breakOuter;
default:
throw new ArgumentException("Expression must be a member expression, eg () => command.InvalidMember", "expr");
}
}
breakOuter:
return ((IEnumerable<string>)parts).Reverse().Join(".");
}
public static QualifiedMember ToTargetMember(
this LinqExp.LambdaExpression memberAccess,
MapperContext mapperContext,
Action <ExpressionType> nonMemberAction)
{
return(memberAccess.ToDlrExpression().ToTargetMember(mapperContext, nonMemberAction));
}
private static string OutputFunctionBody(LambdaExpression function)
{
string body = function.Body.ToString();
body = MemberPattern.Replace(body, string.Empty);
body = BoxingPattern.Replace(body, "$1");
return EscapeForTemplate(body);
}
public static string GetPropertyName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
string parent = "";
if (typeof(TModel) != memberExpression.Expression.Type) /// sub property // to do hierahly cycle
{
var submemember = memberExpression.Expression as System.Linq.Expressions.MemberExpression;
if (submemember != null)
{
parent = submemember.Member.Name + ".";
}
}
return(parent + ((PropertyInfo)memberExpression.Member).Name);
}
/// <summary>Creates a projection plan from the specified <paramref name="projection"/>.</summary>
/// <param name="projection">Projection expression.</param>
/// <param name="normalizerRewrites">Tracks rewrite-to-source rewrites introduced by expression normalizer.</param>
/// <returns>A new <see cref="ProjectionPlan"/> instance.</returns>
internal static ProjectionPlan CompilePlan(LambdaExpression projection, Dictionary<Expression, Expression> normalizerRewrites)
{
Debug.Assert(projection != null, "projection != null");
Debug.Assert(projection.Parameters.Count == 1, "projection.Parameters.Count == 1");
Debug.Assert(
projection.Body.NodeType == ExpressionType.Constant ||
projection.Body.NodeType == ExpressionType.MemberInit ||
projection.Body.NodeType == ExpressionType.MemberAccess ||
projection.Body.NodeType == ExpressionType.Convert ||
projection.Body.NodeType == ExpressionType.ConvertChecked ||
projection.Body.NodeType == ExpressionType.New,
"projection.Body.NodeType == Constant, MemberInit, MemberAccess, Convert(Checked) New");
ProjectionPlanCompiler rewriter = new ProjectionPlanCompiler(normalizerRewrites);
#if TRACE_CLIENT_PROJECTIONS
Trace.WriteLine("Projection: " + projection);
#endif
Expression plan = rewriter.Visit(projection);
#if TRACE_CLIENT_PROJECTIONS
Trace.WriteLine("Becomes: " + plan);
#endif
ProjectionPlan result = new ProjectionPlan();
result.Plan = (Func<object, object, Type, object>)((LambdaExpression)plan).Compile();
result.ProjectedType = projection.Body.Type;
#if DEBUG
result.SourceProjection = projection;
result.TargetProjection = plan;
#endif
return result;
}
public override void SetUp ()
{
base.SetUp();
_keySelector = ExpressionHelper.CreateLambdaExpression<int, short> (i => (short) i);
_elementSelector = ExpressionHelper.CreateLambdaExpression<int, string> (i => i.ToString());
_resultSelectorWithElementSelector =
ExpressionHelper.CreateLambdaExpression<short, IEnumerable<string>, Tuple<short, int>> ((key, group) => Tuple.Create (key, group.Count()));
_sourceEnumerable = ExpressionHelper.CreateIntQueryable();
var methodCallExpressionWithElementSelector = (MethodCallExpression) ExpressionHelper.MakeExpression (
() => _sourceEnumerable.GroupBy (
i => (short) i,
i => i.ToString(),
(key, group) => Tuple.Create (key, group.Count())));
_parseInfoWithElementSelector = new MethodCallExpressionParseInfo ("g", SourceNode, methodCallExpressionWithElementSelector);
_nodeWithElementSelector = new GroupByWithResultSelectorExpressionNode (
_parseInfoWithElementSelector,
_keySelector,
_elementSelector,
_resultSelectorWithElementSelector);
var methodCallExpressionWithoutElementSelector = (MethodCallExpression) ExpressionHelper.MakeExpression (
() => _sourceEnumerable.GroupBy (
i => (short) i,
(key, group) => Tuple.Create (key, group.Count())));
_resultSelectorWithoutElementSelector =
ExpressionHelper.CreateLambdaExpression<short, IEnumerable<int>, Tuple<short, int>> ((key, group) => Tuple.Create (key, group.Count()));
_nodeWithoutElementSelector = new GroupByWithResultSelectorExpressionNode (
new MethodCallExpressionParseInfo ("g", SourceNode, methodCallExpressionWithoutElementSelector),
_keySelector,
_resultSelectorWithoutElementSelector,
null);
}
internal Interpreter(LambdaExpression lambda, bool[] localIsBoxed, int maxStackDepth,
InstructionArray instructions, ExceptionHandler[] handlers, DebugInfo[] debugInfos, int compilationThreshold) {
_lambda = lambda;
_numberOfLocals = localIsBoxed.Length;
if (Array.IndexOf(localIsBoxed, true) != -1) {
_localIsBoxed = localIsBoxed;
} else {
_localIsBoxed = null;
}
_maxStackDepth = maxStackDepth;
_instructions = instructions;
_objects = instructions.Objects;
_handlers = handlers;
_debugInfos = debugInfos;
_onlyFaultHandlers = true;
foreach (var handler in handlers) {
if (!handler.IsFinallyOrFault) {
_onlyFaultHandlers = false;
break;
}
}
_compilationThreshold = compilationThreshold;
}
protected LambdaExpression UpdateLambda(LambdaExpression lambda, Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters)
{
if (body != lambda.Body || parameters != lambda.Parameters || delegateType != lambda.Type) {
return Expression.Lambda(delegateType, body, parameters);
}
return lambda;
}
private void AddInclude(SimpleType source, MemberExpression memberSelector, LambdaExpression collectionInclude)
{
var members = source.GetAllMembers();
if (members.Count > 0 && memberSelector.GetDepth() > 1)
{
var innermostMember = ExpressionUtil.GetInnermostMemberExpression(memberSelector);
foreach (var kvp in members)
{
if (kvp.Key == innermostMember.Member)
{
AddInclude(kvp.Value, ExpressionUtil.ReplaceInnermostMemberExpressionWithParameter(memberSelector) as MemberExpression, collectionInclude);
return;
}
}
}
else
{
var parameter = ExpressionUtil.GetParameterExpression(memberSelector);
if (collectionInclude != null)
{
source.Includes.Add(IncludeDirectiveUtil.GetIncludeInCollectionDirective(memberSelector, collectionInclude));
}
else
{
source.Includes.Add(IncludeDirectiveUtil.GetIncludeDirective(memberSelector));
}
}
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = CommonUtil.IsClientType(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(SR.ALinqCannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(SR.ALinqCannotCreateConstantEntity);
default:
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
public static LambdaExpression Combine(this LambdaExpression outer, LambdaExpression inner)
{
var invoke = Expression.Invoke(inner, outer.Body);
var body = new ExpressionRewriter().AutoInline(invoke);
return Expression.Lambda(body, outer.Parameters.ToArray());
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
default:
// ExpressionType.MemberAccess as a top-level expression is correctly
// processed here, as the lambda isn't being member-initialized.
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
///<summary>
/// Turn an expression like x=< x.User.Name to "User.Name"
///</summary>
public static string ToPropertyPath(this LambdaExpression expr,
char propertySeparator = '.',
char collectionSeparator = ',')
{
var expression = expr.Body;
return(expression.ToPropertyPath(propertySeparator, collectionSeparator));
}
public static string GetExpressionText(System.Linq.Expressions.LambdaExpression expression)
{
if (expression.Body != null && expression.Body.NodeType == System.Linq.Expressions.ExpressionType.Convert)
{
System.Linq.Expressions.UnaryExpression exp = expression.Body as System.Linq.Expressions.UnaryExpression;
expression = System.Linq.Expressions.Expression.Lambda(exp.Operand, expression.Parameters.ToArray <System.Linq.Expressions.ParameterExpression>());
}
return(ExpressionHelper.GetExpressionText(expression));
}
internal override void RewriteBody(PythonAst.LookupVisitor visitor)
{
_dlrBody = null; // clear the cached body if we've been reduced
MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode());
FuncCodeExpr = funcCode;
Body = new PythonAst.RewrittenBodyStatement(Body, visitor.Visit(Body));
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="type"></param>
/// <param name="bDataBase"></param>
/// <returns></returns>
internal static DMS Create(object entity, Type type, string bDataBase)
{
DMS instance = new DMS(type, bDataBase, ConstExpression.WithLock, ConstExpression.NeedParams, ConstExpression.NeedQueryProvider);
var param = System.Linq.Expressions.Expression.Parameter(type);
System.Linq.Expressions.LambdaExpression lambdaExpr = System.Linq.Expressions.LambdaExpression.Lambda(param, param);
instance.TableExpressioin.Append(lambdaExpr);
return(instance);
}
/// <summary>
/// Creates the LambdaExpression which is the actual function body.
/// </summary>
private MSAst.LambdaExpression EnsureFunctionLambda()
{
if (_dlrBody == null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody");
_dlrBody = CreateFunctionLambda();
}
return(_dlrBody);
}
internal override MSAst.LambdaExpression GetLambda()
{
if (_dlrBody == null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody");
_dlrBody = MakeClassBody();
}
return(_dlrBody);
}
private void TraceWriteExpression(string title, System.Linq.Expressions.LambdaExpression expression)
{
Trace.WriteLine("--------------------------> " + title);
Trace.WriteLine(String.Format("Body = {0}", expression.Body));
Trace.WriteLine(String.Format("Name = {0}", expression.Name));
Trace.WriteLine(String.Format("NodeType = {0}", expression.NodeType));
Trace.WriteLine(String.Format("Parameters = {0}", expression.Parameters));
Trace.WriteLine(String.Format("ReturnType = {0}", expression.ReturnType));
Trace.WriteLine(String.Format("Type = {0}", expression.Type));
}
private static IOrderedQueryable<T> Sort<T>(this IQueryable<T> queryable, SystemLinq.LambdaExpression lambdaExpression, MethodInfo methodInfo)
{
queryable.AssertNotNull(nameof(queryable));
var exp = lambdaExpression.CheckNotNull(nameof(lambdaExpression)).Body;
var resultType = exp.Type;
var funcType = typeof(Func<,>).MakeGenericType(typeof(T), resultType);
var lambdaExpressionMethodInfo = MethodInfos.Expression.Lambda.MakeGenericMethod(funcType);
var funcExpression = lambdaExpressionMethodInfo.Invoke(null, new object[] { exp, lambdaExpression.Parameters.ToArray() });
var method = methodInfo.MakeGenericMethod(typeof(T), resultType);
var result = method.Invoke(null, new object[] { queryable, funcExpression! });
static string PropertyNameFromLambdaExpr(Exprs.LambdaExpression expr)
{
if (expr.Body is Exprs.MemberExpression)
{
return(PropertyNameFromMemberExpr(expr.Body as Exprs.MemberExpression));
}
else if (expr.Body is Exprs.UnaryExpression)
{
return(PropertyNameFromUnaryExpr(expr.Body as Exprs.UnaryExpression));
}
throw new NotSupportedException(expr.ToString());
}
static Reflect.MemberInfo MemberFromLambdaExpr(Exprs.LambdaExpression expr)
{
if (expr.Body is Exprs.MemberExpression)
{
return(MemberFromExprMemberExpr(expr.Body as Exprs.MemberExpression));
}
else if (expr.Body is Exprs.UnaryExpression)
{
return(MemberFromExprUnaryExpr(expr.Body as Exprs.UnaryExpression));
}
throw new NotSupportedException(expr.ToString());
}
/// <summary>
/// Returns an expression which creates the function object.
/// </summary>
internal MSAst.Expression MakeFunctionExpression()
{
List <MSAst.Expression> defaults = new List <MSAst.Expression>(0);
foreach (var param in _parameters)
{
if (param.DefaultValue != null)
{
defaults.Add(AstUtils.Convert(param.DefaultValue, typeof(object)));
}
}
MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode());
FuncCodeExpr = funcCode;
MSAst.Expression ret;
if (EmitDebugFunction())
{
MSAst.LambdaExpression code = EnsureFunctionLambda();
// we need to compile all of the debuggable code together at once otherwise mdbg gets confused. If we're
// in tracing mode we'll still compile things one off though just to keep things simple. The code will still
// be debuggable but naive debuggers like mdbg will have more issues.
ret = Ast.Call(
AstMethods.MakeFunctionDebug, // method
Parent.LocalContext, // 1. Emit CodeContext
FuncCodeExpr, // 2. FunctionCode
((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(), // 3. module name
defaults.Count == 0 ? // 4. default values
AstUtils.Constant(null, typeof(object[])) :
(MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults),
IsGenerator ?
(MSAst.Expression) new PythonGeneratorExpression(code, GlobalParent.PyContext.Options.CompilationThreshold) :
(MSAst.Expression)code
);
}
else
{
ret = Ast.Call(
AstMethods.MakeFunction, // method
Parent.LocalContext, // 1. Emit CodeContext
FuncCodeExpr, // 2. FunctionCode
((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(), // 3. module name
defaults.Count == 0 ? // 4. default values
AstUtils.Constant(null, typeof(object[])) :
(MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults)
);
}
return(AddDecorators(ret, _decorators));
}
public static T CreateSetupNode <T>(IFluentNode node, System.Linq.Expressions.LambdaExpression expression)
{
var scope = node.FluentScope.CreateChild();
scope.Set(RegistryKeys.SetupExpression, expression);
//TODO: Get rid of FluentNodeParent (If I can - I think it is only used by EndSetup now. EndSetup should use the same principle as IfScope).
scope.Set(RegistryKeys.FluentNodeParent, node);
//Clear all unwanted inherited values.
scope.Delete(RegistryKeys.Rule);
scope.Delete(RegistryKeys.IsCrossField);
scope.Delete(RegistryKeys.CulpritResolver);
return((T)CreateFluentNode(typeof(T), scope));
}
public static PropertyInfo GetPropertyName <T>(System.Linq.Expressions.Expression <Func <T, object> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
return((PropertyInfo)memberExpression.Member);
}
private MSAst.LambdaExpression TransformGenerator(MSAst.LambdaExpression lambda)
{
GeneratorExpression generator = (GeneratorExpression)lambda.Body;
MSAst.Expression body = generator.Body;
_generatorLabelTarget = generator.Target;
// $TODO: Detect if the label's type is not typeof(object), and create a new label
Debug.Assert(_generatorLabelTarget.Type == typeof(object));
_generatorParams.Add(_frame);
Dictionary <MSAst.ParameterExpression, object> parameters = new Dictionary <MSAst.ParameterExpression, object>();
foreach (MSAst.ParameterExpression parameter in lambda.Parameters)
{
parameters.Add(parameter, null);
}
// Add parameters to the pending list
_pendingLocals.AddRange(lambda.Parameters);
// Run 1st tree walk to identify all locals
LambdaWalker lambdaWalker = new LambdaWalker();
lambdaWalker.Visit(body);
// Add all locals to pending list
_pendingLocals.AddRange(lambdaWalker.Locals);
// Prepare variables
LayoutVariablesForGenerator(parameters);
// Rewrite for generator
MSAst.Expression generatorBody = TransformToGeneratorBody(body);
// Get the generator factory lambda
MSAst.LambdaExpression generatorFactoryLambda = CreateGeneratorFactoryLambda(generatorBody);
// Create FunctionInfo object
CreateFunctionInfo(generatorFactoryLambda);
// Create our own outer generator lambda
return(CreateOuterGeneratorFactory(lambda.Type));
}
/// <summary>
/// Tell bound controls (via WPF binding) to refresh their display.
///
/// Sample call: this.NotifyPropertyChanged(() => this.IsSelected);
/// where 'this' is derived from <seealso cref="BaseViewModel"/>
/// and IsSelected is a property.
/// </summary>
/// <typeparam name="TProperty"></typeparam>
/// <param name="property"></param>
public void RaisePropertyChanged <TProperty>(Expression <Func <TProperty> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (LambdaExpression)property;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
UnaryExpression unaryExpression = (UnaryExpression)lambda.Body;
memberExpression = (MemberExpression)unaryExpression.Operand;
}
else
{
memberExpression = (MemberExpression)lambda.Body;
}
this.RaisePropertyChanged(memberExpression.Member.Name);
}
internal Delegate GetDelegate(RubyScope /*!*/ declaringScope, RubyModule /*!*/ declaringModule)
{
if (_delegate == null)
{
lock (this) {
if (_delegate == null)
{
// TODO: remove options
AstGenerator gen = new AstGenerator(declaringScope.RubyContext, new RubyCompilerOptions(), _document, _encoding, false);
MSA.LambdaExpression lambda = _ast.TransformBody(gen, declaringScope, declaringModule);
_delegate = RubyScriptCode.CompileLambda(lambda, declaringScope.RubyContext);
}
}
}
return(_delegate);
}
public static string GetPropertyName <TModel, TProperty>(System.Linq.Expressions.Expression <Func <TModel, TProperty> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
var xx = (PropertyInfo)memberExpression.Member;
return(((PropertyInfo)memberExpression.Member).Name);
}
/// <summary>
/// Handle a project
/// </summary>
/// <param name="m"></param>
/// <param name="createProjection"></param>
private LE.Expression HandleProjectionOfSingleElement(
System.Linq.Expressions.MethodCallExpression m,
Func <String, NHEX.IProjection> createProjection)
{
if (m.Arguments.Count == 2)
{
LE.LambdaExpression l = (LE.LambdaExpression)Linq.Utils.Expression.StripQuotes(m.Arguments[1]);
LE.MemberExpression me = (LE.MemberExpression)l.Body;
String memberName = me.Member.Name;
ProjectionsPropertyNames.Add(memberName);
projections.Add(createProjection(memberName));
return(LE.Expression.Convert( //Call the GetValue on row passing currentcolumnindex as argument.
LE.Expression.Call(
row,
miGetValue,
LE.Expression.Constant(currentColumnIndex++)),
me.Type));
}
return(m);
}
public static string GetDisplayName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);
memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);
}
var dispnameattr = memberExpression.Member.CustomAttributes.SingleOrDefault(at => at.AttributeType == typeof(DisplayNameAttribute));
if (dispnameattr != null && dispnameattr.ConstructorArguments.Count > 0)
{
return(dispnameattr.ConstructorArguments[0].Value.ToString());
}
return(((PropertyInfo)memberExpression.Member).Name);
}
public static QualifiedMember ToTargetMember(this LinqExp.LambdaExpression memberAccess, MapperContext mapperContext) => memberAccess.ToDlrExpression().ToTargetMember(mapperContext);
private MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda)
{
MSAst.Expression body = lambda.Body;
_lambdaVars.AddRange(new[] { _thread, _framePushed, _funcInfo, _traceLocations, _debugMarker, _frameExitException });
_generatorParams.Add(_frame);
Type returnType = lambda.Type.GetMethod("Invoke").ReturnType;
// Create $retVal variable only if the return type isn't void
if (returnType == typeof(object))
{
_retVal = _retValAsObject;
}
else if (returnType != typeof(void))
{
_retVal = Ast.Variable(returnType, "$retVal");
}
if (_retVal != null)
{
_lambdaVars.Add(_retVal);
_generatorVars.Add(_retVal);
}
_lambdaVars.Add(_retValFromGeneratorLoop);
Dictionary <MSAst.ParameterExpression, object> parameters = new Dictionary <MSAst.ParameterExpression, object>();
foreach (MSAst.ParameterExpression parameter in lambda.Parameters)
{
parameters.Add(parameter, null);
}
// Add parameters to the pending list
_pendingLocals.AddRange(lambda.Parameters);
// Run 1st tree walk to identify all locals
LambdaWalker lambdaWalker = new LambdaWalker();
body = lambdaWalker.Visit(body);
// Add all locals to pending list
_pendingLocals.AddRange(lambdaWalker.Locals);
// Process the variables
LayOutVariables(lambdaWalker.StrongBoxedLocals, parameters);
// Rewrite for generator
MSAst.Expression generatorBody = TransformToGeneratorBody(body);
// Add source file variables
_lambdaVars.AddRange(_sourceFilesMap.Values);
// Create the expression for pushing the frame
CreatePushFrameExpression();
// Rewrite for debuggable body
MSAst.Expression debuggableBody = TransformToDebuggableBody(body);
// Get the generator factory lambda
MSAst.LambdaExpression generatorFactoryLambda = CreateGeneratorFactoryLambda(generatorBody);
// Create FunctionInfo object
CreateFunctionInfo(generatorFactoryLambda);
// Create the outer lambda
return(CreateOuterLambda(lambda.Type, debuggableBody));
}
public void AddConditionOrThrow(LinqExp.LambdaExpression conditionLambda) => AddConditionOrThrow(conditionLambda.ToDlrExpression());
/// <summary>
/// Transforms a LambdaExpression to a debuggable LambdaExpression
/// </summary>
public MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda)
{
ContractUtils.RequiresNotNull(lambda, "lambda");
return(new DebuggableLambdaBuilder(this, new DebugLambdaInfo(null, null, false, null, null, null)).Transform(lambda));
}
