Code Spelling Checker Extension for Visual Studio 2010 (VSX)

using System;


namespace DigitalSamurai.SpellSharp.InputProcessing.Processors
{
    public partial class CSharpProcessor
    {
        public partial class CSharpParser
        {
            public static class ReferencedType
            {
                public static bool Skip (CSharpParsingState current, bool throwError = true)
                {
                    if (current == null)
                    {
                        throw new ArgumentNullException ("current");
                    }

                    if (current.Node == null)
                    {
                        return false;
                    }

                    current.StartScope (ScopeTypes.ReferencedType);
                    try
                    {
                        if (current.IsLexicalElementMemberOf (LexicalElements.Group_LanguageTypes))
                        {
                            current.CommitScopeAndMoveToNext ();
                            return true;
                        }

                        if (current.LexicalElement == LexicalElements.Global)
                        {
                            current.MoveToNextExplicit ();
                            current.IsLexicalElementExpected (LexicalElements.Symbol_Colon_Colon);
                            current.MoveToNextExplicit ();
                        }

                        var isIdentifier = true;
                        while (HasSkippedSection (current, isIdentifier, throwError))
                        {
                            current.MoveToNextExplicit ();

                            isIdentifier = !isIdentifier;
                        }

                        if (isIdentifier)
                        {
                            if (throwError)
                            {
                                throw new ParseException ();
                            }

                            current.RollbackScope ();
                            return false;
                        }

                        switch (current.LexicalElement)
                        {
                            case LexicalElements.Symbol_Asterix:
                                current.MoveToNextExplicit ();
                                break;

                            case LexicalElements.Symbol_SquaredBracketOpen:
                                current.SkipToExplicitly (LexicalElements.Symbol_SquaredBracketClose);
                                current.MoveToNextExplicit ();
                                break;
                        }

                        current.CommitScope ();
                        return true;
                    }
                    catch
                    {
                        current.RollbackScope ();

                        if (throwError)
                        {
                            throw;
                        }

                        return false;
                    }
                }

                private static bool HasSkippedSection (CSharpParsingState current, bool isIdentifier, bool throwError)
                {
                    if (isIdentifier)
                    {
                        if (!HasStartedWith_UnderScoreOrLetter_ContinuesWith_UnderScoreOrLetterOrDigit (current.Token.Text))
                        {
                            if (throwError)
                            {
                                throw new ParseException ();
                            }
                            return false;
                        }

                        return true;
                    }

                    if (current.LexicalElement == LexicalElements.Symbol_AngledBracketOpen)
                    {
                        do
                        {
                            current.MoveToNextExplicit ();

                            ReferencedType.Skip (current);
                        }
                        while (current.LexicalElement == LexicalElements.Symbol_Comma);

                        current.IsLexicalElementExpected (LexicalElements.Symbol_AngledBracketClose);
                        current.MoveToNextExplicit ();
                        return false;
                    }

                    return current.LexicalElement == LexicalElements.Symbol_Dot;
                }


                private static bool HasStartedWith_UnderScoreOrLetter_ContinuesWith_UnderScoreOrLetterOrDigit (string value)
                {
                    if (string.IsNullOrWhiteSpace (value) || !value[0].IsUnderScoreOrLetter ())
                    {
                        return false;
                    }

                    for (int index = 1; index < value.Length; index++)
                    {
                        if (!value[index].IsUnderScoreOrLetterOrDigit ())
                        {
                            return false;
                        }
                    }

                    return true;
                }
            }
        }
    }
}