public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary <string, object> parameters, AsyncCallback callback, object state)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            AsyncManager    asyncHelper         = GetAsyncManager(controllerContext.Controller);
            SingleFireEvent setupCompletedEvent = new SingleFireEvent();

            BeginInvokeCallback beginCallback = (innerCallback, innerState) => {
                ManualAsyncResult asyncResult = new ManualAsyncResult()
                {
                    AsyncState = innerState
                };

                // Get parameters for async setup method, then execute
                ParameterInfo[] setupParametersInfos    = SetupMethod.GetParameters();
                var             rawSetupParameterValues = from parameterInfo in setupParametersInfos
                                                          select ExtractParameterFromDictionary(parameterInfo, parameters, SetupMethod);

                object[] setupParametersArray = rawSetupParameterValues.ToArray();

                // to simplify the logic, force an asynchronous callback
                asyncHelper.OutstandingOperations.Completed += delegate {
                    if (setupCompletedEvent.Signal())
                    {
                        ThreadPool.QueueUserWorkItem(o => {
                            asyncResult.MarkCompleted(false /* completedSynchronously */, innerCallback);
                        });
                    }
                };

                MethodDispatcher setupDispatcher = DispatcherCache.GetDispatcher(SetupMethod);
                asyncHelper.OutstandingOperations.Increment();
                setupDispatcher.Execute(controllerContext.Controller, setupParametersArray);
                asyncHelper.OutstandingOperations.Decrement();
                return(asyncResult);
            };

            AsyncCallback <object> endCallback = ar => {
                if (setupCompletedEvent.Signal())
                {
                    // the setup method did not complete before this callback executed
                    throw new InvalidOperationException(MvcResources.AsyncActionDescriptor_EndExecuteCalledPrematurely);
                }

                // Get parameters for action method, then execute
                ParameterInfo[] completionParametersInfos    = CompletionMethod.GetParameters();
                var             rawCompletionParameterValues = from parameterInfo in completionParametersInfos
                                                               select ExtractParameterOrDefaultFromDictionary(parameterInfo, asyncHelper.Parameters);

                object[] completionParametersArray = rawCompletionParameterValues.ToArray();

                MethodDispatcher completionDispatcher = DispatcherCache.GetDispatcher(CompletionMethod);
                object           actionReturnValue    = completionDispatcher.Execute(controllerContext.Controller, completionParametersArray);
                return(actionReturnValue);
            };

            // Set the timeout and go
            int timeout = asyncHelper.Timeout;

            return(AsyncResultWrapper.WrapWithTimeout(callback, state, beginCallback, endCallback, timeout, _executeTag));
        }
        public override CompletionMethod[] GetMethodOverloads(Vector2 pos)
        {
            //Vector2 originalPos = pos;
            if (parserInterface.lastSourceFile == null) {
                Reparse();
            }

            pos = editor.doc.IncrementPosition(pos,-1);
            pos = editor.doc.IncrementPosition(pos,-1);
            pos = editor.doc.GoToEndOfWhitespace(pos,-1);

            //char nextChar = editor.doc.GetCharAt(pos);
            if (editor.doc.GetCharAt(pos) == '>') {
                ExpressionResolver.editor = editor;
                pos = ExpressionResolver.SimpleMoveToEndOfScope(pos,-1,ExpressionBracketType.Generic);
                pos = editor.doc.GoToEndOfWhitespace(pos,-1);
                if (useUnityscript) {
                    if (editor.doc.GetCharAt(pos) == '.') {
                        pos = editor.doc.IncrementPosition(pos,-1);
                    }
                }
                pos = editor.doc.GoToEndOfWhitespace(pos,-1);
                //GameObject go;
                //go.GetComponent<Vector3>();
            }
            Vector2 endWordPos = pos;

            pos = editor.doc.GoToEndOfWord(pos,-1);
            Vector2 startWordPos = editor.doc.IncrementPosition(pos,1);
            pos = editor.doc.GoToEndOfWhitespace(pos,-1);
            //

            //Debug.Log(editor.doc.GetCharAt(pos));
            bool hasDot = false;
            if (editor.doc.GetCharAt(pos) == '.') {
                if (useUnityscript) {
                    if (editor.doc.GetCharAt(editor.doc.IncrementPosition(pos,1)) != '<') {
                        hasDot = true;
                    }
                }
                else {
                    hasDot = true;
                }
            }

            UIDELine startLine = editor.doc.RealLineAt((int)startWordPos.y);
            string functionName = startLine.rawText.Substring((int)startWordPos.x,((int)endWordPos.x-(int)startWordPos.x)+1);

            pos = editor.doc.IncrementPosition(pos,-1);
            pos = editor.doc.GoToEndOfWhitespace(pos,-1);

            string str = editor.syntaxRule.ResolveExpressionAt(pos,-1);
            if (useUnityscript) {
                str = str.Replace(".<","<");
            }
            //Debug.Log(str);

            CompletionMethod[] methods = new CompletionMethod[0];
            ChainResolver sigChainResolver = new ChainResolver(editor,pos);

            //Handle constructors
            bool isDirectConstructor = str == "new|";
            bool isIndirectConstructor = !isDirectConstructor && str.StartsWith("new|");
            if (isIndirectConstructor && hasDot) {
                isIndirectConstructor = false;
            }
            if (isIndirectConstructor) {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(str+"."+functionName);
                if (item == null || item.finalLinkType == null) {
                    return methods;
                }
                methods = sigChainResolver.GetConstructors(item.finalLinkType);
                return methods;
            }
            else if (isDirectConstructor) {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(functionName);
                if (item == null || item.finalLinkType == null) {
                    return methods;
                }
                methods = sigChainResolver.GetConstructors(item.finalLinkType);
                return methods;
            }

            System.Type type = sigChainResolver.reflectionDB.currentType;
            bool isStatic = false;
            if (hasDot) {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(str,false);
                if (item == null || item.finalLinkType == null) {
                    return methods;
                }
                isStatic = item.finalLink.isStatic;
                type = item.finalLinkType;
            }

            methods = sigChainResolver.GetMethodOverloads(type,functionName,isStatic);

            return methods;
        }
        public override CompletionMethod[] GetMethodOverloads(Vector2 pos)
        {
            //Vector2 originalPos = pos;
            if (parserInterface.lastSourceFile == null)
            {
                Reparse();
            }

            pos = editor.doc.IncrementPosition(pos, -1);
            pos = editor.doc.IncrementPosition(pos, -1);
            pos = editor.doc.GoToEndOfWhitespace(pos, -1);

            //char nextChar = editor.doc.GetCharAt(pos);
            if (editor.doc.GetCharAt(pos) == '>')
            {
                ExpressionResolver.editor = editor;
                pos = ExpressionResolver.SimpleMoveToEndOfScope(pos, -1, ExpressionBracketType.Generic);
                pos = editor.doc.GoToEndOfWhitespace(pos, -1);
                if (useUnityscript)
                {
                    if (editor.doc.GetCharAt(pos) == '.')
                    {
                        pos = editor.doc.IncrementPosition(pos, -1);
                    }
                }
                pos = editor.doc.GoToEndOfWhitespace(pos, -1);
                //GameObject go;
                //go.GetComponent<Vector3>();
            }
            Vector2 endWordPos = pos;

            pos = editor.doc.GoToEndOfWord(pos, -1);
            Vector2 startWordPos = editor.doc.IncrementPosition(pos, 1);

            pos = editor.doc.GoToEndOfWhitespace(pos, -1);
            //

            //Debug.Log(editor.doc.GetCharAt(pos));
            bool hasDot = false;

            if (editor.doc.GetCharAt(pos) == '.')
            {
                if (useUnityscript)
                {
                    if (editor.doc.GetCharAt(editor.doc.IncrementPosition(pos, 1)) != '<')
                    {
                        hasDot = true;
                    }
                }
                else
                {
                    hasDot = true;
                }
            }

            UIDELine startLine    = editor.doc.RealLineAt((int)startWordPos.y);
            string   functionName = startLine.rawText.Substring((int)startWordPos.x, ((int)endWordPos.x - (int)startWordPos.x) + 1);

            pos = editor.doc.IncrementPosition(pos, -1);
            pos = editor.doc.GoToEndOfWhitespace(pos, -1);

            string str = editor.syntaxRule.ResolveExpressionAt(pos, -1);

            if (useUnityscript)
            {
                str = str.Replace(".<", "<");
            }
            //Debug.Log(str);

            CompletionMethod[] methods          = new CompletionMethod[0];
            ChainResolver      sigChainResolver = new ChainResolver(editor, pos);

            //Handle constructors
            bool isDirectConstructor   = str == "new|";
            bool isIndirectConstructor = !isDirectConstructor && str.StartsWith("new|");

            if (isIndirectConstructor && hasDot)
            {
                isIndirectConstructor = false;
            }
            if (isIndirectConstructor)
            {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(str + "." + functionName);
                if (item == null || item.finalLinkType == null)
                {
                    return(methods);
                }
                methods = sigChainResolver.GetConstructors(item.finalLinkType);
                return(methods);
            }
            else if (isDirectConstructor)
            {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(functionName);
                if (item == null || item.finalLinkType == null)
                {
                    return(methods);
                }
                methods = sigChainResolver.GetConstructors(item.finalLinkType);
                return(methods);
            }

            System.Type type     = sigChainResolver.reflectionDB.currentType;
            bool        isStatic = false;

            if (hasDot)
            {
                ChainItem item = null;
                item = sigChainResolver.ResolveChain(str, false);
                if (item == null || item.finalLinkType == null)
                {
                    return(methods);
                }
                isStatic = item.finalLink.isStatic;
                type     = item.finalLinkType;
            }

            methods = sigChainResolver.GetMethodOverloads(type, functionName, isStatic);

            return(methods);
        }