private static bool IsStatic(IReferenceExpression expr)
{
var elem = expr.Reference.Resolve().DeclaredElement;
var typeMember = elem as ITypeMember;
return(typeMember != null && typeMember.IsStatic);
}
public override IAssignableExpression VisitReferenceExpression(IReferenceExpression expr,
IList <IStatement> context)
{
var qualifierExpr = expr.QualifierExpression;
var name = expr.NameIdentifier != null ? expr.NameIdentifier.Name : "";
if (expr == _marker.HandlingNode && _marker.HandlingNode != null)
{
var ce = new CompletionExpression
{
Token = name
};
if (qualifierExpr != null)
{
if (qualifierExpr.IsClassifiedAsVariable ||
qualifierExpr is IInvocationExpression ||
qualifierExpr is IThisExpression ||
qualifierExpr is IBaseExpression)
{
ce.VariableReference = ToVariableRef(qualifierExpr, context);
}
else
{
ce.TypeReference = ToTypeRef(qualifierExpr);
}
}
return(ce);
}
if (IsMember(expr))
{
IVariableReference varRef;
if (IsStatic(expr))
{
varRef = new VariableReference();
}
else
{
varRef = HasImpliciteThis(expr)
? new VariableReference {
Identifier = "this"
}
: ToVariableRef(qualifierExpr, context);
}
return(new ReferenceExpression
{
Reference = GetReference(expr, varRef)
});
}
return(new ReferenceExpression
{
Reference = ToReference(expr, context)
});
}
private static bool IsMember(IReferenceExpression refExpr)
{
if (refExpr == null)
{
return(false);
}
var elem = refExpr.Reference.Resolve().DeclaredElement;
var isMember = elem is IEvent || elem is IField || elem is IMethod || elem is IProperty;
return(isMember);
}
private IReference ToReference(IReferenceExpression refExpr, ITypeMember elem, IList <IStatement> body)
{
IVariableReference baseRef = new VariableReference();
if (!elem.IsStatic)
{
baseRef = HasImpliciteThis(refExpr)
? new VariableReference {
Identifier = "this"
}
: ToVariableRef(refExpr.QualifierExpression, body);
}
return(ToReference(elem, baseRef));
}
private IReference GetReference(IReferenceExpression refExpr, IVariableReference baseRef)
{
if (refExpr != null)
{
var resolveResult = refExpr.Reference.Resolve();
var elem = resolveResult.DeclaredElement;
if (elem == null)
{
return(new UnknownReference());
}
var field = elem as IField;
if (field != null)
{
return(new FieldReference
{
FieldName = field.GetName <IFieldName>(),
Reference = baseRef
});
}
var property = elem as IProperty;
if (property != null)
{
return(new PropertyReference
{
PropertyName = property.GetName <IPropertyName>(),
Reference = baseRef
});
}
var @event = elem as IEvent;
if (@event != null)
{
return(new EventReference
{
EventName = @event.GetName <IEventName>(),
Reference = baseRef
});
}
var method = elem as IMethod;
if (method != null)
{
return(new MethodReference
{
MethodName = method.GetName <IMethodName>(),
Reference = baseRef
});
}
var localVar = elem as ILocalVariable;
var parameter = elem as IParameter;
if (localVar != null || parameter != null)
{
return(new VariableReference {
Identifier = elem.ShortName
});
}
}
return(new UnknownReference());
}
private static bool HasImpliciteThis(IReferenceExpression refExpr)
{
return(IsMember(refExpr) && refExpr.QualifierExpression == null);
}
private static bool IsResolved(IReferenceExpression refExpr)
{
var elem = refExpr.Reference.Resolve().DeclaredElement;
return(elem != null);
}
