private static string GetTypeCheck(MethodArgument methodArgument, int count, string argumentPrefix)
        {
            if (methodArgument.ArrayDepth > 0)
            {
                return string.Format("({0}{1} instanceof Array)", argumentPrefix, count);
            }

            var type = PrimitiveMapper.IsTypeOfMap(methodArgument.Type.Data);
            if (type != null)
            {
                return string.Format(@"(typeof {0}{1} == ""{2}"")", argumentPrefix, count, type);
            }

            return string.Format(@"(typeof {0}{1} == ""function"" || typeof {0}{1} == ""object"")", argumentPrefix, count);
        }
        private void GetArgument()
        {
            var arguments = new List<IList<IInputElement>>();
            var currentArgument = new List<IInputElement>();

            Debug.Assert(CurrentInputElement is SeperatorToken);
            Debug.Assert(CurrentInputElement.Data == "(");
            MoveToNextToken();

            //no arguments
            if (CurrentInputElement.Data == ")")
            {
                MoveToNextToken();
                return;
            }

            while (true)
            {
                if (CurrentInputElement.Data == ",")
                {
                    arguments.Add(currentArgument);
                    currentArgument = new List<IInputElement>();
                    MoveToNextToken();
                    continue;
                }

                if (CurrentInputElement.Data == ")")
                {
                    arguments.Add(currentArgument);
                    currentArgument = new List<IInputElement>();
                    MoveToNextToken();
                    break;
                }

                currentArgument.Add(CurrentInputElement);
                MoveToNextToken();
            }

            foreach (var argument in arguments)
            {
                var methodArgument = new MethodArgument();
                for (var i = 0; i < argument.Count; i++)
                {
                    if (Keywords.MethodModifiers.Any(m => m == argument[i].Data))
                    {
                        methodArgument.Modifier = (KeywordToken)argument[i];
                        continue;
                    }

                    if (argument[i].Data == "[")
                    {
                        i++;
                        Debug.Assert(argument[i].Data == "]");
                        methodArgument.ArrayDepth++;
                        continue;
                    }

                    if (argument.Count >= i + 2 && argument[i].Data == "." && argument[i + 1].Data == "." && argument[i + 2].Data == ".")
                    {
                        methodArgument.IsVariableArity = true;
                        i += 2;
                        continue;
                    }

                    if (methodArgument.Type == null)
                    {
                        methodArgument.Type = (TokenInputElement)argument[i];
                        continue;
                    }

                    if (methodArgument.Name == null)
                    {
                        methodArgument.Name = (TokenInputElement)argument[i];
                        continue;
                    }

                    throw new Exception("Unexpected token.");
                }
                _methodDeclaration.Arguments.Add(methodArgument);
            }
        }
 public MethodArgumentCompiler(ICompiler compiler, MethodArgument methodArgument)
 {
     _compiler = compiler;
     _methodArgument = methodArgument;
 }