public override void OnMemberReferenceExpression(MemberReferenceExpression node)
{
if (PhantomDslEngine.IsCleanupMethod(node.ParentNode)) {
ReplaceCurrentNode(new StringLiteralExpression(node.ToCodeString()));
}
}
private void MarkRelatedImportAsUsed(MemberReferenceExpression node)
{
string ns = null;
foreach (var import in _currentModule.Imports)
{
if (ImportAnnotations.IsUsedImport(import)) continue;
if (null == ns) ns = node.ToCodeString();
if (import.Namespace == ns)
{
ImportAnnotations.MarkAsUsed(import);
break;
}
}
}
protected virtual void ProcessMemberReferenceExpression(MemberReferenceExpression node)
{
IEntity member = ResolveMember(node);
if (null == member) return;
if (EntityType.Ambiguous == member.EntityType)
{
member = ResolveAmbiguousReference(node, (Ambiguous)member);
}
EnsureRelatedNodeWasVisited(node, member);
if (EntityType.Namespace == member.EntityType)
{
string ns = null;
foreach (Import import in _currentModule.Imports)
{
if (import.NamespaceUsed) continue;
if (null == ns) ns = node.ToCodeString();
if (import.Namespace == ns)
{
import.NamespaceUsed = true;
break;
}
}
}
IMember memberInfo = member as IMember;
if (null != memberInfo)
{
if (!AssertTargetContext(node, memberInfo))
{
Error(node);
return;
}
if (EntityType.Method != memberInfo.EntityType)
{
BindExpressionType(node, GetInferredType(memberInfo));
}
else
{
BindExpressionType(node, memberInfo.Type);
}
}
if (EntityType.Property == member.EntityType)
{
IProperty property = (IProperty)member;
if (IsIndexedProperty(property))
{
if (!AstUtil.IsTargetOfSlicing(node)
&& (!property.IsExtension || property.GetParameters().Length > 1))
{
Error(node, CompilerErrorFactory.PropertyRequiresParameters(
AstUtil.GetMemberAnchor(node),
member.FullName));
return;
}
}
if (IsWriteOnlyProperty(property) && !IsBeingAssignedTo(node))
{
Error(node, CompilerErrorFactory.PropertyIsWriteOnly(
AstUtil.GetMemberAnchor(node),
member.FullName));
}
}
else if (EntityType.Event == member.EntityType)
{
if (!AstUtil.IsTargetOfMethodInvocation(node) &&
!AstUtil.IsLhsOfInPlaceAddSubtract(node))
{
if (CurrentType == memberInfo.DeclaringType)
{
InternalEvent ev = (InternalEvent)member;
node.Name = ev.BackingField.Name;
node.Entity = ev.BackingField;
BindExpressionType(node, ev.BackingField.Type);
return;
}
else
{
Error(node,
CompilerErrorFactory.EventIsNotAnExpression(node,
member.FullName));
}
}
}
Bind(node, member);
PostProcessReferenceExpression(node);
}
