override public void LeaveExpressionPair(ExpressionPair pair)
{
Expression converted = ConvertExpression(pair.First);
if (null != converted)
{
pair.First = converted;
}
converted = ConvertExpression(pair.Second);
if (null != converted)
{
pair.Second = converted;
}
}
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));
}
private bool ProcessNamedArgument(ExpressionPair arg)
{
Visit(arg.Second);
if (NodeType.ReferenceExpression != arg.First.NodeType)
{
Error(arg.First, CompilerErrorFactory.NamedParameterMustBeIdentifier(arg));
return false;
}
return true;
}
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 ExpressionPair expression_pair() //throws RecognitionException, TokenStreamException
{
ExpressionPair ep;
IToken t = null;
ep = null;
Expression key = null;
Expression value = null;
try { // for error handling
key=expression();
t = LT(1);
match(COLON);
value=expression();
if (0==inputState.guessing)
{
ep = new ExpressionPair(ToLexicalInfo(t), key, value);
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "expression_pair");
recover(ex,tokenSet_130_);
}
else
{
throw ex;
}
}
return ep;
}
public static CompilerError NamedParameterMustBeIdentifier(ExpressionPair pair)
{
return new CompilerError("BCE0002", SafeLexicalInfo(pair.First));
}
public static CompilerError NamedParameterMustBeIdentifier(ExpressionPair pair)
{
return Instantiate("BCE0002", pair.First);
}
bool SetFieldOrProperty(IAstAttribute aa, ExpressionPair p)
{
ReferenceExpression name = p.First as ReferenceExpression;
if (null == name)
{
_context.Errors.Add(CompilerErrorFactory.NamedParameterMustBeIdentifier(p));
return false;
}
else
{
Reflection.MemberInfo[] members = _type.FindMembers(
Reflection.MemberTypes.Property | Reflection.MemberTypes.Field,
Reflection.BindingFlags.Instance | Reflection.BindingFlags.Public,
Type.FilterName, name.Name);
if (members.Length > 0)
{
if (members.Length > 1)
{
_context.Errors.Add(CompilerErrorFactory.AmbiguousReference(name, members));
return false;
}
else
{
Reflection.MemberInfo m = members[0];
Reflection.PropertyInfo property = m as Reflection.PropertyInfo;
if (null != property)
{
property.SetValue(aa, p.Second, null);
}
else
{
Reflection.FieldInfo field = m as Reflection.FieldInfo;
if (null != field)
{
field.SetValue(aa, p.Second);
}
else
{
throw new InvalidOperationException();
}
}
}
}
else
{
_context.Errors.Add(CompilerErrorFactory.NotAPublicFieldOrProperty(name, name.Name, _type.FullName));
return false;
}
}
return true;
}
public override void OnExpressionPair(ExpressionPair pair)
{
Visit(pair.First);
Write(": ");
Visit(pair.Second);
}
bool SetFieldOrProperty(IAstAttribute aa, ExpressionPair p)
{
var name = p.First as ReferenceExpression;
if (name == null)
{
_context.Errors.Add(CompilerErrorFactory.NamedParameterMustBeIdentifier(p));
return false;
}
var members = FindMembers(name);
if (members.Length <= 0)
{
_context.Errors.Add(CompilerErrorFactory.NotAPublicFieldOrProperty(name, name.Name, Type()));
return false;
}
if (members.Length > 1)
{
_context.Errors.Add(CompilerErrorFactory.AmbiguousReference(name, members));
return false;
}
var member = members[0];
var property = member as PropertyInfo;
if (property != null)
{
property.SetValue(aa, p.Second, null);
return true;
}
var field = (FieldInfo)member;
field.SetValue(aa, p.Second);
return true;
}
public ExpressionPair expression_pair()
{
ExpressionPair pair = null;
IToken token = null;
try
{
Expression expression = this.expression();
token = this.LT(1);
this.match(0x42);
Expression expression2 = this.expression();
if (base.inputState.guessing == 0)
{
pair = new ExpressionPair(ToLexicalInfo(token), expression, expression2);
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_40_);
return pair;
}
return pair;
}
override public object Clone()
{
ExpressionPair clone = new ExpressionPair();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
if (null != _first)
{
clone._first = _first.Clone() as Expression;
clone._first.InitializeParent(clone);
}
if (null != _second)
{
clone._second = _second.Clone() as Expression;
clone._second.InitializeParent(clone);
}
return clone;
}
