|
private Field ( |
||
| expression | ||
| field | ||
| 리턴 | ||
/// <summary>
/// Takes current result and wraps it into try-filter(MethodUnwinder)-finally block that ensures correct "break" behavior for
/// Ruby method calls with a block given in arguments.
///
/// Sets up a RFC frame similarly to MethodDeclaration.
/// </summary>
internal static void ApplyBlockFlowHandlingInternal(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args)
{
// TODO (improvement):
// We don't special case null block here, although we could (we would need a test for that then).
// We could also statically know (via call-site flag) that the current method is not a proc-converter (passed by ref),
// which would make such calls faster.
if (metaBuilder.Error || !args.Signature.HasBlock)
{
return;
}
Expression rfcVariable = metaBuilder.GetTemporary(typeof(RuntimeFlowControl), "#rfc");
ParameterExpression methodUnwinder = metaBuilder.GetTemporary(typeof(MethodUnwinder), "#unwinder");
Expression resultVariable = metaBuilder.GetTemporary(typeof(object), "#result");
metaBuilder.Result = Ast.Block(
// initialize frame (RFC):
Ast.Assign(rfcVariable, Methods.CreateRfcForMethod.OpCall(AstUtils.Convert(args.GetBlockExpression(), typeof(Proc)))),
AstUtils.Try(
Ast.Assign(resultVariable, metaBuilder.Result)
).Filter(methodUnwinder, Ast.Equal(Ast.Field(methodUnwinder, MethodUnwinder.TargetFrameField), rfcVariable),
// return unwinder.ReturnValue;
Ast.Assign(resultVariable, Ast.Field(methodUnwinder, MethodUnwinder.ReturnValueField))
).Finally(
// we need to mark the RFC dead snce the block might escape and break later:
Ast.Assign(Ast.Field(rfcVariable, RuntimeFlowControl.IsActiveMethodField), Ast.Constant(false))
),
resultVariable
);
}
public TExSB(Expression ex) : base(ex)
{
bpi = TExPI.Box(Ex.Field(ex, "bpi"));
scale = Ex.Field(ex, "scale");
direction = new TExV2(Ex.Field(ex, "direction"));
velocity = new TExMov(Ex.Field(ex, "movement"));
}
protected TExSB(ExMode m, string?name) : base(m, name)
{
bpi = TExPI.Box(Ex.Field(ex, "bpi"));
scale = Ex.Field(ex, "scale");
direction = new TExV2(Ex.Field(ex, "direction"));
velocity = new TExMov(Ex.Field(ex, "movement"));
}
public static Func <T, TR> FieldGet <T, TR>(this Type type, string fieldName)
{
var param = Expression.Parameter(type, "arg");
var member = Expression.Field(param, fieldName);
var lambda = Expression.Lambda(member, param);
return((Func <T, TR>)lambda.Compile());
}
public TExRV2(Expression ex) : base(ex)
{
nx = Ex.Field(ex, "nx");
ny = Ex.Field(ex, "ny");
rx = Ex.Field(ex, "rx");
ry = Ex.Field(ex, "ry");
angle = Ex.Field(ex, "angle");
}
public TExRV2(ExMode m, string?name) : base(m, name)
{
nx = Ex.Field(ex, "nx");
ny = Ex.Field(ex, "ny");
rx = Ex.Field(ex, "rx");
ry = Ex.Field(ex, "ry");
angle = Ex.Field(ex, "angle");
}
public static Getter <TG> FieldGet <TG>(string fieldName)
{
var type = Expression.Parameter(typeof(T), "type");
var field = Expression.Field(type, fieldName);
var lambda = Expression.Lambda(field, type);
return((Getter <TG>)lambda.Compile());
}
public void MemberAccess_field_expression()
{
var expression =
LinqExpression.Field(
LinqExpression.Parameter(typeof(SampleClass)),
nameof(SampleClass.InstanceField));
ShouldRoundrip(expression);
}
public void MemberAccess_field_type()
{
var expression =
LinqExpression.Field(
null,
typeof(SampleClass),
nameof(SampleClass.StaticField));
ShouldRoundrip(expression);
}
public static Func <object, object> FieldGet(this Type type, string fieldName)
{
var param = Expression.Parameter(typeof(object), "arg");
var paramCast = Expression.Convert(param, type);
var member = Expression.Field(paramCast, fieldName);
var memberCast = Expression.Convert(member, typeof(object));
var lambda = Expression.Lambda(memberCast, param);
return((Func <object, object>)lambda.Compile());
}
protected TExPI(ExMode m, string?name) : base(m, name)
{
id = Ex.Field(ex, "id");
t = Ex.Field(ex, "t");
loc = Ex.Field(ex, "loc");
locx = Ex.Field(loc, "x");
locy = Ex.Field(loc, "y");
index = Ex.Field(ex, "index");
findex = Ex.Convert(index, ExUtils.tfloat);
}
Exp Call(Exp obj, string name, Exp arg0)
{
return(Exp.Call(obj, Callvirt, Exp.Constant(name),
Exp.Block
(
Exp.Assign(Exp.Field(arg1, "self"), obj),
Exp.Assign(Exp.ArrayAccess(Exp.Field(arg1, "Input"), Exp.Constant(0)), arg0),
arg1
)));
}
/// <summary>Generate a specific member getter for a specific type</summary>
/// <typeparam name="T">The type which contains the member</typeparam>
/// <typeparam name="TResult">The static member's actual type</typeparam>
/// <param name="memberName">The member's name as defined in <typeparamref name="T"/></param>
/// <returns>A compiled lambda which can access (get) the static member</returns>
/// <remarks>Generates a method similar to this:
/// <code>
/// TResult GetMethod()
/// {
/// return T.memberName;
/// }
/// </code>
/// </remarks>
public static Func <TResult> GenerateStaticFieldGetter <T, TResult>(string memberName)
{
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <Func <TResult> >() != null);
var member = Expr.Field(null, typeof(T), memberName); // basically 'T.memberName'
var lambda = Expr.Lambda <Func <TResult> >(member);
return(lambda.Compile());
}
public TExPI(Expression ex) : base(ex)
{
id = Ex.Field(ex, "id");
t = Ex.Field(ex, "t");
loc = Ex.Field(ex, "loc");
locx = Ex.Field(loc, "x");
locy = Ex.Field(loc, "y");
index = Ex.Field(ex, "index");
findex = Ex.Convert(index, ExUtils.tfloat);
}
public TExGCX(Expression ex_) : base(ex_)
{
fs = Ex.Field(ex, "fs");
v2s = Ex.Field(ex, "v2s");
v3s = Ex.Field(ex, "v3s");
rv2s = Ex.Field(ex, "rv2s");
index = Ex.Field(ex, "index");
i_float = Ex.Field(ex, "i").As <float>();
pi_float = Ex.Field(ex, "pi").As <float>();
beh_loc = Ex.Property(ex, "Loc");
bpi = Ex.Property(ex, "AsBPI");
}
public static Setter <TS> FieldSet <TS>(string fieldName)
{
var type = Expression.Parameter(typeof(T), "type");
var value = Expression.Parameter(typeof(TS), "value");
var field = Expression.Field(type, fieldName);
#if NET_40 && !WINDOWS_PHONE
var assign = Expression.Assign(field, value);
#else
var assign = Expression.Call(MethodInfoAssign, field, value);
#endif
var lambda = Expression.Lambda(assign, type, value);
return((Setter <TS>)lambda.Compile());
}
public void ReplaceMember()
{
var x = V <Vector2>("x");
var y = VF("y");
var ex = Ex.Block(new[] { x }, Ex.Assign(x, ExC(new Vector2(2f, 3f))), Ex.Field(x, "x").Add(ExC(6f)));
AreEqual("((x=(2.0, 3.0));\n(x.x+6);)", ex.Debug());
AreEqual("((x=(2.0, 3.0));\n8;)", ex.FlatDebug());
AreEqual(Compile(ex.Flatten()), 8f);
ex = Ex.Block(new[] { x }, Ex.Assign(x, ExC(new Vector2(2f, 3f))), Ex.IfThen(y.GT(E1), x.Is(ExC(Vector2.right))), Ex.Add(Ex.Field(x, "x"), ExC(6f)));
AreEqual("((x=(2.0, 3.0));\nif(y>1){(x=(1.0, 0.0))}else{};\n(x.x+6);)", ex.FlatDebug());
ex = Ex.Block(new[] { x }, x.Is(ExC(new Vector2(2f, 3f))), Ex.IfThen(y.GT(E1), Ex.Field(x, "x").Is(ExC(6f))), Ex.Add(Ex.Field(x, "x"), ExC(6f)));
AreEqual("((x=(2.0, 3.0));\nif(y>1){(x.x=6)}else{};\n(x.x+6);)", ex.FlatDebug());
}
/// <summary>
/// Takes current result and wraps it into try-filter(MethodUnwinder)-finally block that ensures correct "break" behavior for
/// library method calls with block given in bfcVariable (BlockParam).
/// </summary>
internal static void ApplyBlockFlowHandlingInternal(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args)
{
if (metaBuilder.Error)
{
return;
}
Expression expression = metaBuilder.Result;
Expression bfcVariable = metaBuilder.BfcVariable;
// Method call with proc can invoke control flow that returns an arbitrary value from the call, so we need to type result to Object.
// Otherwise, the result could only be result of targetExpression unless its return type is void.
Type resultType = (bfcVariable != null) ? typeof(object) : expression.Type;
Expression resultVariable;
if (resultType != typeof(void))
{
resultVariable = metaBuilder.GetTemporary(resultType, "#result");
}
else
{
resultVariable = Expression.Empty();
}
if (expression.Type != typeof(void))
{
expression = Ast.Assign(resultVariable, AstUtils.Convert(expression, resultType));
}
// a non-null proc is being passed to the callee:
if (bfcVariable != null)
{
ParameterExpression methodUnwinder = metaBuilder.GetTemporary(typeof(MethodUnwinder), "#unwinder");
expression = AstFactory.Block(
Ast.Assign(bfcVariable, Methods.CreateBfcForLibraryMethod.OpCall(AstUtils.Convert(args.GetBlockExpression(), typeof(Proc)))),
AstUtils.Try(
expression
).Filter(methodUnwinder, Methods.IsProcConverterTarget.OpCall(bfcVariable, methodUnwinder),
Ast.Assign(resultVariable, Ast.Field(methodUnwinder, MethodUnwinder.ReturnValueField))
).Finally(
Methods.LeaveProcConverter.OpCall(bfcVariable)
),
resultVariable
);
}
metaBuilder.Result = expression;
}
/// <summary>Generate a specific static field setter for a specific reference type</summary>
/// <typeparam name="T">The type which contains the member</typeparam>
/// <typeparam name="TValue">The static member's actual type</typeparam>
/// <param name="memberName">The member's name as defined in <typeparamref name="T"/></param>
/// <returns>A compiled lambda which can access (set) the member</returns>
/// <exception cref="MemberAccessException"><paramref name="memberName"/> is readonly</exception>
/// <remarks>Generates a method similar to this:
/// <code>
/// void SetMethod(TValue value)
/// {
/// T.memberName = value;
/// }
/// </code>
/// </remarks>
public static Action <TValue> GenerateStaticFieldSetter <T, TValue>(string memberName)
where T : class
{
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <Action <TValue> >() != null);
var param_value = Expr.Parameter(typeof(TValue), kValueName); // the member's new value
var member = Expr.Field(null, typeof(T), memberName); // i.e., 'T.memberName'
ValidateMemberForGenerateSetter(member.Member);
var assign = Expr.Assign(member, param_value); // i.e., 'T.memberName = value'
var lambda = Expr.Lambda <Action <TValue> >(assign, param_value);
return(lambda.Compile());
}
public static Func <object, object, object> FieldSet(this Type type, string fieldName)
{
var param = Expression.Parameter(typeof(object), "arg");
var paramCast = Expression.Convert(param, type);
var member = Expression.Field(paramCast, fieldName);
var value = Expression.Parameter(typeof(object), "value");
#if NET_40 && !WINDOWS_PHONE
var valueCast = Expression.Convert(value, member.Type);
var assign = Expression.Assign(member, valueCast);
var memberCast = Expression.Convert(assign, typeof(object));
var lambda = Expression.Lambda(memberCast, param, value);
#else
// TODO: Check this alternative
var memberCast = Expression.Convert(member, typeof(object));
var assign = Expression.Call(Class <object> .MethodInfoAssign, memberCast, value);
var lambda = Expression.Lambda(assign, param, value);
#endif
return((Func <object, object, object>)lambda.Compile());
}
public GlobalExpr()
{
expr = LinqExpr.Field(LinqExpr.Constant(this), typeof(GlobalExpr <T>), "x");
}
/// <summary>
/// Creates verifier which checks object public properties.
/// </summary>
/// <typeparam name="TVerifier">Verifier type.</typeparam>
/// <param name="propertyFilter">Object public properties filter; can be null to generate code for all the properties.</param>
/// <param name="checkExprFunc">Function which generates property value check expression (if returns true then check is failed).
/// Function obtains variable which holds property value and additional arguments.</param>
/// <param name="createExceptionExpr">New exception creation expression used when check is failed.</param>
/// <returns>Verifier instance.</returns>
public static TVerifier Create <TVerifier>(
Func <Type, bool> propertyFilter,
Func <Expression, IList <ParameterExpression>, Expr> checkExprFunc,
LambdaExpression createExceptionExpr) where TVerifier : class
{
VerifyUtil.NotNull(checkExprFunc, "checkExprFunc");
VerifyUtil.NotNull(createExceptionExpr, "createExceptionExpr");
Type argumentsType = typeof(TVerifier).GetGenericArguments()[0];
Type type = argumentsType.GetGenericArguments()[0];
// Prepare lambda action parameters - first is Argument<T>, others are additionalParamTypes
var objectParam = Expr.Parameter(argumentsType);
var objectVar = Expr.Parameter(type);
var genericArguments = typeof(TVerifier).GetGenericArguments();
var additionalParams = genericArguments.Skip(1).Take(genericArguments.Length - 2).Select(Expr.Parameter).ToList();
Expr lambdaBody;
if (type.IsAnonymous())
{
// Take createExceptionExpr lambda, extract first parameter from it and replace additional parameters in body
var exceptionNameParam = createExceptionExpr.Parameters[0];
var exceptionObjectParam = createExceptionExpr.Parameters[1];
var exceptionBody = createExceptionExpr.ReplaceParams(additionalParams);
// Obtain type public properties to check
propertyFilter = propertyFilter ?? (_ => true);
var properties = type.GetProperties().OrderBy(pi => pi.Name).Where(pi => propertyFilter(pi.PropertyType));
// Obtain argument values from fields since it's faster
var fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).OrderBy(fi => fi.Name).Where(fi => propertyFilter(fi.FieldType)).ToList();
// Generate "if (checkExpr) then throw createExceptionExpr;" for each of the properties
var propertyChecks = properties
.Select(
(pi, i) =>
{
var valueVar = Expr.Field(objectVar, fields[i]);
return((Expr)Expr.IfThen(
checkExprFunc(valueVar, additionalParams),
Expr.Throw(
exceptionBody
.Replace(exceptionNameParam, Expr.Constant(pi.Name))
.Replace(exceptionObjectParam, valueVar.ConvertIfNeeded(exceptionObjectParam.Type)))));
})
.ToList();
// Prepare null check - if null is supplied then all checks are passed since nothing to check
var checksBody = propertyChecks.Any()
? Expr.IfThen(
Expr.ReferenceNotEqual(objectVar, Expr.Constant(null, type)),
propertyChecks.Count > 1 ? Expr.Block(propertyChecks) : propertyChecks[0])
: null;
lambdaBody = propertyChecks.Any()
? (Expr)Expr.Block(
new[] { objectVar },
new Expr[] { Expr.Assign(objectVar, Expr.Field(objectParam, "Holder")) }
.Concat(new[] { checksBody })
.Concat(new[] { objectParam }))
: objectParam;
}
else
{
// Not anonymous type - throw an exception
lambdaBody = Expr.Block(
Expr.Throw(
Expr.New(
VerifyArgsExceptionCtor,
Expr.Constant(string.Format(ErrorMessages.NotAnonymousType, type)))),
objectParam);
}
// Pull it all together, execute checks only if supplied object is not null
var lambda = Expr.Lambda <TVerifier>(
lambdaBody,
new[] { objectParam }.Concat(additionalParams));
return(lambda.Compile());
}
public TExV2(ExMode m, string?name) : base(m, name)
{
x = Ex.Field(ex, "x");
y = Ex.Field(ex, "y");
}
public TExV2(Expression ex) : base(ex)
{
x = Ex.Field(ex, "x");
y = Ex.Field(ex, "y");
}
protected override LExpression GetExpressionTreeIfPossible(
LExpression contextExpression,
LExpression evalContext)
{
// TODO: odczyt const-ów! jak to zrobiæ! bo nie chc¹ siê emitowaæ! kurwa! co za gówno!
// TODO: czy lock jest potrzebny? tutaj? chyba nie?
// TODO: czy czasami nie bêdzie tak, ¿e kompilacja ZAWSZE bêdzie w locku???
lock (this)
{
IValueAccessor acc = null;
var name = getText();
var finalContextExpression = contextExpression;
var contextExpressionType = contextExpression.Type;
if (contextExpressionType == typeof(Type) &&
contextExpression.NodeType == ExpressionType.Constant)
{
// System.Type or type that it represents (e.g. Int32)
contextExpressionType = (Type)((ConstantExpression)contextExpression).Value;
finalContextExpression = null;
// try inner type (e.g. Int32)
acc = GetPropertyOrFieldAccessor(contextExpressionType, name, BINDING_FLAGS);
if (acc == null)
{
// not found - going back to System.Type
contextExpressionType = contextExpression.Type;
finalContextExpression = contextExpression;
}
}
if (acc == null)
{
acc = GetPropertyOrFieldAccessor(contextExpressionType, name, BINDING_FLAGS);
}
var propertyAcc = acc as PropertyValueAccessor;
if (propertyAcc != null)
{
return(LExpression.Property(
finalContextExpression,
(PropertyInfo)propertyAcc.MemberInfo));
}
var fieldAcc = acc as FieldValueAccessor;
if (fieldAcc != null)
{
if (fieldAcc.FieldInfo.IsStatic && fieldAcc.FieldInfo.IsLiteral)
{
// const field - have to JIT a value!
object fieldValue = fieldAcc.Get(null);
return(LExpression.Constant(
fieldValue,
fieldAcc.FieldInfo.FieldType));
}
return(LExpression.Field(
finalContextExpression,
(FieldInfo)fieldAcc.MemberInfo));
}
// final call - Type!
{
var type = TypeResolutionUtils.ResolveType(name);
if (type != null)
{
// if (!type.IsValueType)
// {
return(LExpression.Constant(type, typeof(Type)));
// }
// else
// {
// return
// LExpression.Convert(
// LExpression.Constant(type, typeof(Type)),
// typeof(object));
// }
}
}
return(null);
}
}
public override SysExpr ToExpression() => SysExpr.Field(Expression.ToExpression(), FieldInfo);
private static CloneDelegate <T> GetObjectCloner <T>(Type type, CloneContext context)
{
Delegate result;
var cache = context.Cache;
var key = new CacheKey(typeof(T), type);
if (!cache.TryGetValue(key, out result))
{
var statements = new List <LinqExpression>();
var param = LinqExpression.Parameter(typeof(T).MakeByRefType(), "input");
var output = LinqExpression.Parameter(typeof(T).MakeByRefType(), "output");
var contextParam = LinqExpression.Parameter(typeof(CloneContext), "context");
ParameterExpression localCast;
ParameterExpression localOutput;
ParameterExpression localObj;
bool isStruct = type.IsValueType && typeof(T) == type;
bool isArray = type.IsArray;
if (isStruct || isArray)
{
localCast = param;
localOutput = output;
localObj = null;
}
else
{
localObj = LinqExpression.Variable(typeof(object), "localObj");
localCast = LinqExpression.Variable(type, "localCast");
localOutput = LinqExpression.Variable(type, "localOut");
statements.Add(LinqExpression.Assign(localCast, LinqExpression.Convert(param, type)));
if (context.IsSelfClone)
{
statements.Add(LinqExpression.Call(contextParam, MethodAdd, param, param));
statements.Add(LinqExpression.Assign(output, localCast));
}
else
{
// NOTE: this can fail if there is no default constructor for type.
// for example Dictionary<K,T>.ValueCollection, which is created when a access to members Keys or Values is performed on the dicitonary.
statements.Add(LinqExpression.Assign(localOutput, LinqExpression.New(type)));
statements.Add(LinqExpression.Assign(output, localOutput));
statements.Add(LinqExpression.Call(contextParam, MethodAdd, param, localOutput));
}
}
var fields = GetFields(type);
// If we have a struct with primitive only
if (isArray)
{
var genericCloneMethod = DeepcloneArray.GetGenericMethodDefinition();
genericCloneMethod = genericCloneMethod.MakeGenericMethod(new[] { type.GetElementType() });
statements.Add(LinqExpression.Call(genericCloneMethod, localCast, localOutput, contextParam));
}
else if (isStruct && fields.All(field => IsPrimitive(field.FieldType)))
{
statements.Add(LinqExpression.Assign(localOutput, param));
}
else
{
foreach (var field in fields)
{
if (field.IsInitOnly)
{
throw new InvalidOperationException(String.Format("Field [{0}] in [{1}] is readonly, which is not supported in DeepClone", field.Name, type));
}
var t = field.FieldType;
if (t.IsSubclassOf(typeof(Delegate)))
{
continue;
}
var value = LinqExpression.Field(localCast, field);
LinqExpression cloneField = null;
if (IsPrimitive(t))
{
if (!context.IsSelfClone)
{
cloneField = LinqExpression.Assign(LinqExpression.Field(localOutput, field), value);
}
}
else
{
MethodInfo genericCloneMethod;
if (field.FieldType.IsArray)
{
genericCloneMethod = DeepcloneArray.GetGenericMethodDefinition();
genericCloneMethod = genericCloneMethod.MakeGenericMethod(new[] { field.FieldType.GetElementType() });
}
else
{
genericCloneMethod = DeepcloneObject.GetGenericMethodDefinition();
genericCloneMethod = genericCloneMethod.MakeGenericMethod(new[] { field.FieldType });
}
cloneField = LinqExpression.Call(genericCloneMethod, value, context.IsSelfClone ? value : LinqExpression.Field(localOutput, field), contextParam);
}
if (cloneField != null)
{
statements.Add(cloneField);
}
}
}
LinqExpression body;
if (isStruct || isArray)
{
if (statements.Count == 0)
{
body = LinqExpression.Empty();
}
else
{
body = LinqExpression.Block(statements);
}
}
else
{
var innerBody = LinqExpression.Block(new[] { localCast, localOutput }, statements);
body = LinqExpression.Block(
new[] { localObj },
LinqExpression.IfThenElse(
LinqExpression.Call(contextParam, MethodTryGetValue, param, localObj), LinqExpression.Assign(output, LinqExpression.Convert(localObj, typeof(T))), innerBody));
}
var tempLambda = LinqExpression.Lambda <CloneDelegate <T> >(body, param, output, contextParam);
result = tempLambda.Compile();
cache.Add(key, result);
}
return((CloneDelegate <T>)result);
}
public static Ex dLookupSinDeg(TEx <double> angleDeg) => Ex.Field(dLookupCosSinDeg(angleDeg), "y");
/// <summary>
/// Builds the childrens iterator.
/// </summary>
/// <param name="rootType">Type of the root.</param>
/// <returns>
/// A function that is able to process childrens from a node
/// </returns>
private static NodeProcessor BuildChildrensIterator(Type rootType)
{
var sourceParameter = LinqExpression.Parameter(typeof(Node), "source");
var explorerParameter = LinqExpression.Parameter(typeof(NodeProcessorContext).MakeByRefType(), "nodeProcessorContext");
var variableNodeProcessor = LinqExpression.Variable(typeof(NodeProcessor), "nodeProcessor");
var variableNodeListProcessor = LinqExpression.Variable(typeof(NodeListProcessor), "listProcessor");
var statements = new List <LinqExpression>();
// Cast source variable
var castVar = LinqExpression.Variable(rootType, "cast");
var variables = new List <ParameterExpression> {
castVar, variableNodeProcessor, variableNodeListProcessor
};
statements.Add(LinqExpression.Assign(castVar, LinqExpression.Convert(sourceParameter, rootType)));
statements.Add(LinqExpression.Assign(variableNodeProcessor, LinqExpression.Field(explorerParameter, nodeProcessorProperty)));
statements.Add(LinqExpression.Assign(variableNodeListProcessor, LinqExpression.Field(explorerParameter, nodeListProcessorProperty)));
// Get all types from most inherited
var types = new List <Type>();
for (var type = rootType; type != null; type = type.GetTypeInfo().BaseType)
{
types.Add(type);
}
types.Reverse();
// Iterate on inherited types
foreach (var type in types)
{
// Iterate on all properties in order to create the iterator.
foreach (var sourceField in type.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
{
// If the property is not read-writable or contains a visitor ignore attribute, skip it
if (sourceField.GetCustomAttribute <VisitorIgnoreAttribute>(true) != null)
{
continue;
}
var propertyType = sourceField.FieldType;
var interfaces = propertyType.GetTypeInfo().ImplementedInterfaces;
// Get the property type and check if the property inherit from IList<>
if (!typeof(StatementList).GetTypeInfo().IsAssignableFrom(propertyType.GetTypeInfo()))
{
foreach (var interfaceBase in interfaces)
{
if (interfaceBase.GetTypeInfo().IsGenericType&& interfaceBase.GetTypeInfo().GetGenericTypeDefinition() == typeof(IList <>))
{
var parameterType = interfaceBase.GetTypeInfo().GenericTypeArguments[0];
if (typeof(Node).GetTypeInfo().IsAssignableFrom(parameterType.GetTypeInfo()))
{
statements.Add(
LinqExpression.Invoke(variableNodeListProcessor, LinqExpression.Field(castVar, sourceField), explorerParameter));
}
break;
}
}
}
if (typeof(Node).GetTypeInfo().IsAssignableFrom(propertyType.GetTypeInfo()))
{
statements.Add(
LinqExpression.Assign(
LinqExpression.Field(castVar, sourceField),
LinqExpression.Convert(LinqExpression.Invoke(variableNodeProcessor, LinqExpression.Field(castVar, sourceField), explorerParameter), propertyType)));
}
}
}
// Return source parameter
statements.Add(sourceParameter);
// Lambda body
var block = LinqExpression.Block(variables, statements);
// Create lambda and return a compiled version
var lambda = LinqExpression.Lambda <NodeProcessor>(block, sourceParameter, explorerParameter);
return(lambda.Compile());
}
public static Ex dLookupSinRad(TEx <double> angleRad) => Ex.Field(dLookupCosSinRad(angleRad), "y");