protected override void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
{
if (!TypeSystemServices.IsQuackBuiltin(pair.First))
{
base.AddResolvedNamedArgumentToEval(eval, pair, instance);
return;
}
MemberReferenceExpression memberRef = new MemberReferenceExpression(
pair.First.LexicalInfo,
instance.CloneNode(),
((ReferenceExpression)pair.First).Name);
BindQuack(memberRef);
eval.Arguments.Add(
CodeBuilder.CreateAssignment(
pair.First.LexicalInfo,
memberRef,
pair.Second));
}
public override void OnCollectionInitializationExpression(CollectionInitializationExpression node)
{
var temp = new ReferenceExpression(node.LexicalInfo, Context.GetUniqueName("collection"));
var initialization = CodeBuilder.CreateEvalInvocation(node.LexicalInfo);
// temp = $(node.Collection)
initialization.Arguments.Add(new BinaryExpression(BinaryOperatorType.Assign, temp, node.Collection));
if (node.Initializer is ListLiteralExpression)
foreach (var item in ((ListLiteralExpression)node.Initializer).Items)
// temp.Add(item)
initialization.Arguments.Add(NewAddInvocation(item.LexicalInfo, temp, item));
else
foreach (var pair in ((HashLiteralExpression)node.Initializer).Items)
// temp.Add(key, value)
initialization.Arguments.Add(NewAddInvocation(pair.LexicalInfo, temp, pair.First, pair.Second));
// return temp
initialization.Arguments.Add(temp.CloneNode());
ReplaceCurrentNode(initialization);
}
protected virtual void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
{
IEntity entity = GetEntity(pair.First);
switch (entity.EntityType)
{
case EntityType.Event:
{
IEvent member = (IEvent)entity;
eval.Arguments.Add(
CodeBuilder.CreateMethodInvocation(
pair.First.LexicalInfo,
instance.CloneNode(),
member.GetAddMethod(),
pair.Second));
break;
}
case EntityType.Field:
{
eval.Arguments.Add(
CodeBuilder.CreateAssignment(
pair.First.LexicalInfo,
CodeBuilder.CreateMemberReference(
instance.CloneNode(),
(IMember)entity),
pair.Second));
break;
}
case EntityType.Property:
{
IProperty property = (IProperty)entity;
IMethod setter = property.GetSetMethod();
if (null == setter)
{
Error(CompilerErrorFactory.PropertyIsReadOnly(pair.First, property));
}
else
{
//EnsureRelatedNodeWasVisited(pair.First, setter);
eval.Arguments.Add(
CodeBuilder.CreateAssignment(
pair.First.LexicalInfo,
CodeBuilder.CreateMemberReference(
instance.CloneNode(),
property),
pair.Second));
}
break;
}
}
}
protected Expression ProcessTargets(Expression node)
{
// Look for safe access operators in the targets chain
UnaryExpression ue = null;
Expression target = node;
Expression nextTarget = null;
while (IsTargetable(target))
{
if (target is MemberReferenceExpression)
{
nextTarget = ((MemberReferenceExpression)target).Target;
}
else if (target is SlicingExpression)
{
nextTarget = ((SlicingExpression)target).Target;
}
else
{
nextTarget = ((MethodInvocationExpression)target).Target;
}
if (IsSafeAccess(nextTarget))
{
ue = (UnaryExpression)nextTarget;
break;
}
target = nextTarget;
}
// No safe access operator was found
if (ue == null)
{
return null;
}
// Target the safe access to a temporary variable
var tmp = new ReferenceExpression(node.LexicalInfo, Context.GetUniqueName("safe"));
tmp.IsSynthetic = true;
// Make sure preceding operators are processed
MemberReferenceExpression mre = null;
SlicingExpression se = null;
MethodInvocationExpression mie = null;
if (null != (mre = target as MemberReferenceExpression))
{
Visit(mre.Target);
mre.Target = tmp.CloneNode();
}
else if (null != (se = target as SlicingExpression))
{
Visit(se.Target);
se.Target = tmp.CloneNode();
}
else if (null != (mie = target as MethodInvocationExpression))
{
Visit(mie.Target);
mie.Target = tmp.CloneNode();
}
// Convert the target into a ternary operation
var tern = new ConditionalExpression(node.LexicalInfo);
tern.Condition = new BinaryExpression(
BinaryOperatorType.ReferenceInequality,
CodeBuilder.CreateAssignment(tmp, ue.Operand),
CodeBuilder.CreateNullLiteral()
);
tern.TrueValue = node;
tern.FalseValue = CodeBuilder.CreateNullLiteral();
return tern;
}
private static SlicingExpression CreateRawArraySlicing(ReferenceExpression arrayRef, Expression numRef, IType elementType)
{
SlicingExpression expression = new SlicingExpression(arrayRef.CloneNode(), numRef.CloneNode());
expression.ExpressionType = elementType;
AstAnnotations.MarkRawArrayIndexing(expression);
return expression;
}
private static MethodInvocationExpression NewAddInvocation(LexicalInfo location, ReferenceExpression target, params Expression[] args)
{
return new MethodInvocationExpression(location, new MemberReferenceExpression(target.CloneNode(), "Add"), args);
}