public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
{
string name = binder.Name;
if (name == _info.Name)
{
name = "TypeLibDesc";
}
else if (name != "Guid" &&
name != "Name" &&
name != "VersionMajor" &&
name != "VersionMinor")
{
return(binder.FallbackGetMember(this));
}
return(new DynamicMetaObject(
Expression.Convert(
Expression.Property(
AstUtils.Convert(Expression, typeof(ComTypeLibInfo)),
typeof(ComTypeLibInfo).GetProperty(name)
),
typeof(object)
),
ComTypeLibInfoRestrictions(this)
));
}
private DynamicMetaObject TryBindGetMember(string name)
{
if (_lib.HasMember(name))
{
BindingRestrictions restrictions =
BindingRestrictions.GetTypeRestriction(
Expression, typeof(ComTypeLibDesc)
).Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Equal(
Expression.Property(
AstUtils.Convert(
Expression, typeof(ComTypeLibDesc)
),
typeof(ComTypeLibDesc).GetProperty(nameof(ComTypeLibDesc.Guid))
),
Expression.Constant(_lib.Guid)
)
)
);
return(new DynamicMetaObject(
Expression.Constant(
((ComTypeLibDesc)Value).GetTypeLibObjectDesc(name)
),
restrictions
));
}
return(null);
}
private BindingRestrictions EnumRestrictions()
{
return(BindingRestrictions.GetTypeRestriction(
Expression, typeof(ComTypeEnumDesc)
).Merge(
// ((ComTypeEnumDesc)<arg>).TypeLib.Guid == <guid>
BindingRestrictions.GetExpressionRestriction(
Expression.Equal(
Expression.Property(
Expression.Property(
AstUtils.Convert(Expression, typeof(ComTypeEnumDesc)),
typeof(ComTypeDesc).GetProperty("TypeLib")),
typeof(ComTypeLibDesc).GetProperty("Guid")),
AstUtils.Constant(_desc.TypeLib.Guid)
)
)
).Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Equal(
Expression.Property(
AstUtils.Convert(Expression, typeof(ComTypeEnumDesc)),
typeof(ComTypeEnumDesc).GetProperty("TypeName")
),
AstUtils.Constant(_desc.TypeName)
)
)
));
}
protected override Expression VisitParameter(ParameterExpression node)
{
Expression closureItem = GetClosureItem(node, true);
if (closureItem is null)
{
return(node);
}
// Convert can go away if we switch to strongly typed StrongBox
return(AstUtils.Convert(closureItem, node.Type));
}
public DynamicMetaObject GetMetaObject(Expression parameter, int index)
{
return(DynamicMetaObject.Create(
GetArgument(index),
Expression.Call(
s_getArgMethod,
AstUtils.Convert(parameter, typeof(ArgumentArray)),
AstUtils.Constant(index)
)
));
}
public override DynamicMetaObject BindCreateInstance(CreateInstanceBinder binder, DynamicMetaObject[] args)
{
return(new DynamicMetaObject(
Expression.Call(
AstUtils.Convert(Expression, typeof(ComTypeClassDesc)),
typeof(ComTypeClassDesc).GetMethod("CreateInstance")
),
BindingRestrictions.Combine(args).Merge(
BindingRestrictions.GetTypeRestriction(Expression, typeof(ComTypeClassDesc))
)
));
}
protected override Expression VisitRuntimeVariables(RuntimeVariablesExpression node)
{
int count = node.Variables.Count;
var boxes = new List <Expression>();
var vars = new List <ParameterExpression>();
var indexes = new int[count];
for (int i = 0; i < count; i++)
{
Expression box = GetClosureItem(node.Variables[i], false);
if (box is null)
{
indexes[i] = vars.Count;
vars.Add(node.Variables[i]);
}
else
{
indexes[i] = -1 - boxes.Count;
boxes.Add(box);
}
}
// No variables were rewritten. Just return the original node.
if (boxes.Count == 0)
{
return(node);
}
var boxesArray = Expression.NewArrayInit(typeof(IStrongBox), boxes);
// All of them were rewritten. Just return the array, wrapped in a
// read-only collection.
if (vars.Count == 0)
{
return(Expression.Invoke(
Expression.Constant((Func <IStrongBox[], IRuntimeVariables>)RuntimeVariables.Create),
boxesArray
));
}
// Otherwise, we need to return an object that merges them
Func <IRuntimeVariables, IRuntimeVariables, int[], IRuntimeVariables> helper = MergedRuntimeVariables.Create;
return(Expression.Invoke(AstUtils.Constant(helper), Expression.RuntimeVariables(vars), boxesArray, AstUtils.Constant(indexes)));
}
protected override Expression VisitBinary(BinaryExpression node)
{
if (node.NodeType == ExpressionType.Assign &&
node.Left.NodeType == ExpressionType.Parameter)
{
var variable = (ParameterExpression)node.Left;
Expression closureItem = GetClosureItem(variable, true);
if (closureItem != null)
{
// We need to convert to object to store the value in the box.
return(Expression.Block(
new[] { variable },
Expression.Assign(variable, Visit(node.Right)),
Expression.Assign(closureItem, AstUtils.Convert(variable, typeof(object))),
variable
));
}
}
return(base.VisitBinary(node));
}
//TODO enable sharing of these custom delegates
private Delegate CreateCustomDelegate(Type delegateType)
{
//PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Synchronously compiling a custom delegate");
var method = delegateType.GetMethod("Invoke");
var paramInfos = method.GetParameters();
var parameters = new ParameterExpression[paramInfos.Length];
var parametersAsObject = new Expression[paramInfos.Length];
for (int i = 0; i < paramInfos.Length; i++)
{
ParameterExpression parameter = Expression.Parameter(paramInfos[i].ParameterType, paramInfos[i].Name);
parameters[i] = parameter;
parametersAsObject[i] = Expression.Convert(parameter, typeof(object));
}
var data = Expression.NewArrayInit(typeof(object), parametersAsObject);
var self = AstUtils.Constant(this);
var runMethod = typeof(LightLambda).GetMethod("Run");
var body = Expression.Convert(Expression.Call(self, runMethod, data), method.ReturnType);
var lambda = Expression.Lambda(delegateType, body, parameters);
return(lambda.Compile());
}
