/// <summary>
/// Sets the current object.
/// </summary>
/// <param name="calledObject">The called object.</param>
/// <param name="currNode">The curr node.</param>
/// <param name="dispatchSetter">if set to <c>true</c> [dispatch setter].</param>
/// <returns><c>true</c> if current object is correctly set, <c>false</c> otherwise.</returns>
private bool setCurrentObject(RValueProvider calledObject, INodeAST currNode, bool dispatchSetter)
{
if (calledObject != null && currNode != null && currNode.Indexer != null)
{
if (dispatchSetter)
{
//nothing to do here - setters are created in LNode value processing
}
else
{
var searcher = createMethodSearcher(calledObject);
searcher.Dispatch(Naming.IndexerGetter);
calledObject = resolveCall(calledObject, currNode, searcher.FoundResult);
if (calledObject == null)
{
//indexer hasn't been found
return(false);
}
//reset searcher, because object has been found
_searcher = null;
}
}
_currentObject = calledObject;
return(true);
}
/// <summary>
/// Try to get call hierarchy (chained calls, properties, indexes, namespaces and statit classes).
/// </summary>
/// <param name="call">Result representation of call hierarchy.</param>
/// <param name="calledObject">Object on which call hierarchy starts if any.</param>
/// <returns><c>true</c> if call hierarchy is recognized, <c>false</c> otherwise.</returns>
internal bool TryGetSetter(out LValueProvider call, RValueProvider calledObject)
{
var currNode = initializeCallSearch(calledObject, _entryNode.Child == null);
while (currNode != null)
{
if (currNode.Child == null)
{
//setter could be only the last child in hierarchy
call = processLNode(currNode);
return(call != null);
}
if (!processRNode(currNode))
{
break;
}
currNode = currNode.Child;
//there is indexer on last child - get it as rvalue
if (currNode.Child == null && currNode.Indexer != null && !processRNode(currNode))
{
//indexer setters are handled in
//different way than getters
break;
}
}
//setter hasnt been found
call = null;
return(false);
}
/// <summary>
/// Resolves the call.
/// </summary>
/// <param name="calledObject">The called object.</param>
/// <param name="currNode">The curr node.</param>
/// <param name="overloads">The overloads.</param>
/// <returns>CallValue.</returns>
private CallValue resolveCall(RValueProvider calledObject, INodeAST currNode, IEnumerable <TypeMethodInfo> overloads)
{
var callActivation = _compiler.CreateCallActivation(calledObject, currNode, overloads);
if (callActivation == null)
{
//overloads doesnt match to arguments
return(null);
}
return(new CallValue(callActivation, Context));
}
/// <summary>
/// Initializes the call search.
/// </summary>
/// <param name="calledObject">The called object.</param>
/// <param name="dispatchSetter">if set to <c>true</c> [dispatch setter].</param>
/// <returns>INodeAST.</returns>
private INodeAST initializeCallSearch(RValueProvider calledObject, bool dispatchSetter)
{
_searcher = createMethodSearcher(calledObject);
setCurrentObject(calledObject, _entryNode, dispatchSetter && _entryNode.Child == null);
var isCallNode = _entryNode.NodeType == NodeTypes.call;
var needEntryNode = calledObject == null || dispatchSetter || isCallNode;
//if there is a called object, entry node has been already used for it
var currNode = needEntryNode ? _entryNode : _entryNode.Child;
return(currNode);
}
public SetterLValue(TypeMethodInfo setter, RValueProvider thisObject, IEnumerable <Argument> positionalArguments, CompilationContext context)
: base(context)
{
_setter = setter;
_thisObjet = thisObject;
//defensive copy
_positionArguments = positionalArguments.ToArray();
if (!_setter.IsStatic && thisObject == null)
{
throw new ArgumentNullException("thisObject");
}
}
/// <summary>
/// Try to get call hierarchy (chained calls, properties, indexes, namespaces and statit classes).
/// </summary>
/// <param name="call">Result representation of call hierarchy.</param>
/// <param name="calledObject">Object on which call hierarchy starts if any.</param>
/// <returns><c>true</c> if call hierarchy is recognized, <c>false</c> otherwise.</returns>
internal bool TryGetCall(out RValueProvider call, RValueProvider calledObject)
{
var currNode = initializeCallSearch(calledObject, false);
while (currNode != null)
{
if (!processRNode(currNode))
{
break;
}
currNode = currNode.Child;
}
call = _currentObject;
//if searcher is null, it means that there are no
//buffered nodes left within the searcher
return(_searcher == null);
}
/// <summary>
/// Create method searcher filled with valid namespaces according to calledObject.
/// </summary>
/// <param name="calledObject">The called object.</param>
/// <returns>Created <see cref="MethodSearcher" />.</returns>
private MethodSearcher createMethodSearcher(RValueProvider calledObject)
{
//x without base can resolve to:
//[this namespace].this.get_x /this.set_x
//[this namespace].[static class x]
//[this namespace].[namespace x]
//[imported namespaces].[static class x]
//[imported namespaces].[namespace x]
var searcher = Context.CreateSearcher();
if (calledObject == null)
{
searcher.ExtendName(_compiler.Namespaces.ToArray());
}
else
{
var calledObjectInfo = calledObject.Type;
searcher.SetCalledObject(calledObjectInfo);
}
return(searcher);
}
/// <summary>
/// Add call argument into current activation.
/// <remarks>Ordering of arguments is considered</remarks>
/// </summary>
/// <param name="arg">Added argument</param>
internal void AddArgument(RValueProvider arg)
{
_arguments.Add(arg);
}
public ImplicitCastRValue(RValueProvider castedValue, TypeDescriptor castedType, CompilationContext context)
: base(context)
{
_castedValue = castedValue;
CastedType = castedType;
}
internal void SetCtor(RValueProvider ctorCall)
{
_ctorCall = ctorCall;
}
internal Argument(RValueProvider value)
{
Value = value;
Name = null;
}
