Exemplo n.º 1
0
        /// <summary>
        /// Checks the placement and formatting of parameters to a method invocation or a method declaration.
        /// </summary>
        /// <param name="element">
        /// The element.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens that form the parameter list.
        /// </param>
        /// <param name="methodArguments">
        /// The arguments or parameters to the method.
        /// </param>
        /// <param name="methodStartLineNumber">
        /// The line number on which the method begins.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the parameter list opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the parameter list closing bracket.
        /// </param>
        /// <param name="friendlyTypeText">
        /// The text to use for violations.
        /// </param>
        private void CheckParameters(
            CsElement element,
            CsTokenList parameterListTokens,
            IArgumentList methodArguments,
            int methodStartLineNumber,
            CsTokenType openBracketType,
            CsTokenType closeBracketType,
            string friendlyTypeText)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.AssertNotNull(methodArguments, "methodArguments");
            Param.AssertGreaterThanZero(methodStartLineNumber, "methodStartLineNumber");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            Node <CsToken> openingBracketNode = this.CheckMethodOpeningBracket(element, parameterListTokens, openBracketType, friendlyTypeText);

            if (openingBracketNode != null)
            {
                this.CheckMethodClosingBracket(element, parameterListTokens, openingBracketNode, closeBracketType, methodArguments);

                if (methodArguments.Count > 0)
                {
                    this.CheckMethodArgumentList(element, methodArguments, openingBracketNode, methodStartLineNumber, friendlyTypeText);
                }
            }
        }
Exemplo n.º 2
0
        private bool IsValueExpression(Expression expression)
        {
            if (expression is LiteralExpression)
            {
                CsTokenType tokenType = ((LiteralExpression)expression).Token.CsTokenType;

                return(tokenType == CsTokenType.Number ||
                       tokenType == CsTokenType.String ||
                       tokenType == CsTokenType.Null ||
                       tokenType == CsTokenType.True ||
                       tokenType == CsTokenType.False);
            }

            if (expression is ParenthesizedExpression)
            {
                return(this.IsValueExpression(((ParenthesizedExpression)expression).InnerExpression));
            }

            if (expression is RelationalExpression)
            {
                RelationalExpression re = (RelationalExpression)expression;
                return(this.IsValueExpression(re.LeftHandSide) && this.IsValueExpression(re.RightHandSide));
            }

            if (expression is ArithmeticExpression)
            {
                ArithmeticExpression ae = (ArithmeticExpression)expression;
                return(this.IsValueExpression(ae.LeftHandSide) && this.IsValueExpression(ae.RightHandSide));
            }

            return(false);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Determines the amount of offset to add to the line number of the next parameter
        /// for a comment or attribute.
        /// </summary>
        /// <param name="tokenNode">
        /// The token node.
        /// </param>
        /// <returns>
        /// Returns the amount of offset to add.
        /// </returns>
        private static int ParameterPrewordOffset(Node <CsToken> tokenNode)
        {
            Param.AssertNotNull(tokenNode, "tokenNode");

            Debug.Assert(
                tokenNode.Value.CsTokenType == CsTokenType.Attribute || tokenNode.Value.CsTokenType == CsTokenType.SingleLineComment ||
                tokenNode.Value.CsTokenType == CsTokenType.MultiLineComment,
                "The token must be an attribute or a comment.");

            // Find the start of the next parameter.
            for (Node <CsToken> node = tokenNode.Next; node != null; node = node.Next)
            {
                CsTokenType tokenType = node.Value.CsTokenType;

                if (tokenType == CsTokenType.EndOfLine)
                {
                    return(tokenNode.Value.Location.LineSpan);
                }
                else if (tokenType != CsTokenType.WhiteSpace && tokenType != CsTokenType.MultiLineComment && tokenType != CsTokenType.SingleLineComment &&
                         tokenType != CsTokenType.Attribute)
                {
                    return(Math.Max(0, node.Value.Location.StartPoint.LineNumber - tokenNode.Value.Location.StartPoint.LineNumber));
                }
            }

            return(0);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Gets the tokens forming the parameter list for a method declaration.
        /// </summary>
        /// <param name="tokens">
        /// The tokens forming the method declaration.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <returns>
        /// Returns the parameter list or null if it cannot be found.
        /// </returns>
        private static CsTokenList GetParameterListTokens(CsTokenList tokens, CsTokenType openBracketType, CsTokenType closeBracketType)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            return(GetArgumentListTokens(tokens, tokens.First, openBracketType, closeBracketType));
        }
        public static bool HasToken(this ICodeUnit codeUnit, CsTokenType tokenType)
        {
            if (codeUnit == null)
            {
                return false;
            }

            return codeUnit.Tokens.Any(x => x.CsTokenType == tokenType);
        }
Exemplo n.º 6
0
        public static string GetTokenType(CsTokenType pTokenType)
        {
            if (_typeRef.ContainsKey(pTokenType))
            {
                return(_typeRef[pTokenType]);
            }

            throw new Exception(@"Unknown Typeref: " + pTokenType);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Initializes a new instance of the Bracket class.
        /// </summary>
        /// <param name="text">
        /// The token string.
        /// </param>
        /// <param name="tokenType">
        /// The token type.
        /// </param>
        /// <param name="location">
        /// The location of the token within the code document.
        /// </param>
        /// <param name="parent">
        /// The parent code part.
        /// </param>
        /// <param name="generated">
        /// True if the token is inside of a block of generated code.
        /// </param>
        internal Bracket(string text, CsTokenType tokenType, CodeLocation location, Reference <ICodePart> parent, bool generated)
            : base(text, tokenType, CsTokenClass.Bracket, location, parent, generated)
        {
            Param.Ignore(text, tokenType, location, parent, generated);

            Debug.Assert(
                tokenType == CsTokenType.OpenCurlyBracket || tokenType == CsTokenType.CloseCurlyBracket || tokenType == CsTokenType.OpenSquareBracket ||
                tokenType == CsTokenType.CloseSquareBracket || tokenType == CsTokenType.OpenParenthesis || tokenType == CsTokenType.CloseParenthesis ||
                tokenType == CsTokenType.OpenGenericBracket || tokenType == CsTokenType.CloseGenericBracket || tokenType == CsTokenType.OpenAttributeBracket ||
                tokenType == CsTokenType.CloseAttributeBracket,
                "The symbol is not a bracket type.");
        }
        /// <summary>
        /// Initializes a new instance of the Bracket class.
        /// </summary>
        /// <param name="text">
        /// The token string.
        /// </param>
        /// <param name="tokenType">
        /// The token type.
        /// </param>
        /// <param name="location">
        /// The location of the token within the code document.
        /// </param>
        /// <param name="parent">
        /// The parent code part.
        /// </param>
        /// <param name="generated">
        /// True if the token is inside of a block of generated code.
        /// </param>
        internal Bracket(string text, CsTokenType tokenType, CodeLocation location, Reference<ICodePart> parent, bool generated)
            : base(text, tokenType, CsTokenClass.Bracket, location, parent, generated)
        {
            Param.Ignore(text, tokenType, location, parent, generated);

            Debug.Assert(
                tokenType == CsTokenType.OpenCurlyBracket || tokenType == CsTokenType.CloseCurlyBracket || tokenType == CsTokenType.OpenSquareBracket
                || tokenType == CsTokenType.CloseSquareBracket || tokenType == CsTokenType.OpenParenthesis || tokenType == CsTokenType.CloseParenthesis
                || tokenType == CsTokenType.OpenGenericBracket || tokenType == CsTokenType.CloseGenericBracket || tokenType == CsTokenType.OpenAttributeBracket
                || tokenType == CsTokenType.CloseAttributeBracket, 
                "The symbol is not a bracket type.");
        }
Exemplo n.º 9
0
        /// <summary>
        /// Initializes a new instance of the CsToken class.
        /// </summary>
        /// <param name="tokenType">
        /// The token type.
        /// </param>
        /// <param name="tokenClass">
        /// The token class.
        /// </param>
        /// <param name="location">
        /// The location of the token within the code document.
        /// </param>
        /// <param name="parent">
        /// References the parent code part.
        /// </param>
        /// <param name="generated">
        /// True if the token is inside of a block of generated code.
        /// </param>
        internal CsToken(CsTokenType tokenType, CsTokenClass tokenClass, CodeLocation location, Reference <ICodePart> parent, bool generated)
        {
            Param.Ignore(tokenType);
            Param.Ignore(tokenClass);
            Param.AssertNotNull(location, "location");
            Param.AssertNotNull(parent, "parent");
            Param.Ignore(generated);

            this.tokenType  = tokenType;
            this.tokenClass = tokenClass;
            this.location   = location;
            this.parent     = parent;
            this.generated  = generated;
        }
Exemplo n.º 10
0
        private void ProcessStringOperator(CsTokenType csTokenType)
        {
            switch (csTokenType)
            {
            case CsTokenType.tkPLUS:

                var stringType = typeof(string);
                var parms      = new Type[] { stringType, stringType };
                var method     = stringType.GetMethod("Concat", BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, parms, null);

                methodGenerator.EmitCall(OpCodes.Call, method, parms);

                break;
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Checks a method or method invocation to ensure that the opening bracket is
        /// on the same line as the method declaration.
        /// </summary>
        /// <param name="element">
        /// The element containing the expression.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens in the parameter list.
        /// </param>
        /// <param name="openingBracketType">
        /// The type of the bracket that opens the parameter list.
        /// </param>
        /// <param name="textToUseForContainingElement">
        /// The text to use in the violation.
        /// </param>
        /// <returns>
        /// Returns the opening bracket.
        /// </returns>
        private Node <CsToken> CheckMethodOpeningBracket(
            CsElement element, CsTokenList parameterListTokens, CsTokenType openingBracketType, string textToUseForContainingElement)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.Ignore(openingBracketType);

            // Find the opening bracket.
            Node <CsToken> openingBracketNode = null;

            for (Node <CsToken> tokenNode = parameterListTokens.First; tokenNode != null; tokenNode = tokenNode.Next)
            {
                if (tokenNode.Value.CsTokenType == openingBracketType)
                {
                    openingBracketNode = tokenNode;
                    break;
                }
            }

            CsToken lastWord = null;

            if (openingBracketNode != null)
            {
                // Find the last word before the opening bracket.
                for (Node <CsToken> tokenNode = openingBracketNode.Previous; tokenNode != null; tokenNode = tokenNode.Previous)
                {
                    if (tokenNode.Value.CsTokenType != CsTokenType.WhiteSpace && tokenNode.Value.CsTokenType != CsTokenType.EndOfLine &&
                        tokenNode.Value.CsTokenType != CsTokenType.SingleLineComment && tokenNode.Value.CsTokenType != CsTokenType.MultiLineComment)
                    {
                        lastWord = tokenNode.Value;
                        break;
                    }
                }
            }

            if (lastWord != null)
            {
                if (openingBracketNode.Value.LineNumber != lastWord.LineNumber)
                {
                    this.AddViolation(element, openingBracketNode.Value.LineNumber, Rules.OpeningParenthesisMustBeOnDeclarationLine, textToUseForContainingElement);
                }
            }

            return(openingBracketNode);
        }
Exemplo n.º 12
0
        private static CsTokenType convertToken(CsTokenType pInToken)
        {
            switch (pInToken)
            {
            case CsTokenType.tkPLUS_EQ:
                return(CsTokenType.tkPLUS);

            case CsTokenType.tkMINUS_EQ:
                return(CsTokenType.tkMINUS);

            case CsTokenType.tkDIV_EQ:
                return(CsTokenType.tkDIV);

            case CsTokenType.tkMUL_EQ:
                return(CsTokenType.tkSTAR);

            case CsTokenType.tkMOD_EQ:
                return(CsTokenType.tkMOD);

            default:
                throw new Exception();
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Processes the given element.
        /// </summary>
        /// <param name="element">
        /// The element being visited.
        /// </param>
        private void CheckMethodParameters(CsElement element)
        {
            Param.AssertNotNull(element, "element");

            IList <Parameter> parameters       = null;
            CsTokenType       openBracketType  = CsTokenType.OpenParenthesis;
            CsTokenType       closeBracketType = CsTokenType.CloseParenthesis;

            if (element.ElementType == ElementType.Constructor)
            {
                parameters = ((Constructor)element).Parameters;
            }
            else if (element.ElementType == ElementType.Delegate)
            {
                parameters = ((Delegate)element).Parameters;
            }
            else if (element.ElementType == ElementType.Method)
            {
                parameters = ((Method)element).Parameters;
            }
            else if (element.ElementType == ElementType.Indexer)
            {
                parameters       = ((Indexer)element).Parameters;
                openBracketType  = CsTokenType.OpenSquareBracket;
                closeBracketType = CsTokenType.CloseSquareBracket;
            }

            if (parameters != null)
            {
                ParameterList parameterList       = new ParameterList(parameters);
                CsTokenList   parameterListTokens = GetParameterListTokens(element.Declaration.Tokens, openBracketType, closeBracketType);
                if (parameterListTokens != null)
                {
                    this.CheckParameters(element, parameterListTokens, parameterList, element.LineNumber, openBracketType, closeBracketType, element.FriendlyTypeText);
                }
            }
        }
Exemplo n.º 14
0
 internal Bracket(string text, CsTokenType tokenType, CodeLocation location, bool generated)
     : base(text, tokenType, CsTokenClass.Bracket, location, generated)
 {
 }
        /*
        /// <summary>
        /// Measures the number of lines taken up by comments and attributes before the given word.
        /// </summary>
        /// <param name="start">The start token.</param>
        /// <returns>Returs the number of lines taken up.</returns>
        private static int MeasureCommentLinesBefore(Node<CsToken> start)
        {
            Param.AssertNotNull(start, "start");

            int lineSpan = 0;
            int nextLineSpan = -1;
            int nextStartLineNumber = -1;

            for (Node<CsToken> tokenNode = start.Previous; tokenNode != null; tokenNode = tokenNode.Previous)
            {
                if (tokenNode.Value.CsTokenType == CsTokenType.SingleLineComment ||
                    tokenNode.Value.CsTokenType == CsTokenType.MultiLineComment ||
                    tokenNode.Value.CsTokenType == CsTokenType.Attribute)
                {
                    int itemLineSpan = ParameterPrewordOffset(tokenNode);

                    if (nextStartLineNumber > 0 && tokenNode.Value.Location.EndPoint.LineNumber == nextStartLineNumber && nextLineSpan > 0)
                    {
                        --itemLineSpan;
                    }

                    lineSpan += itemLineSpan;
                    nextLineSpan = itemLineSpan;
                    nextStartLineNumber = tokenNode.Value.LineNumber;
                }
            }

            return lineSpan;
        }
        */

        /// <summary>
        /// Gets the tokens forming the argument list for a method call.
        /// </summary>
        /// <param name="tokens">
        /// The tokens forming the method call.
        /// </param>
        /// <param name="methodNameLastToken">
        /// The last token before the argument list begins.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <returns>
        /// Returns the argument list or null if it cannot be found.
        /// </returns>
        private static CsTokenList GetArgumentListTokens(CsTokenList tokens, Node<CsToken> methodNameLastToken, CsTokenType openBracketType, CsTokenType closeBracketType)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(methodNameLastToken, "methodNameLastToken");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            Debug.Assert(methodNameLastToken.Index <= tokens.Last.Index && methodNameLastToken.Index >= tokens.First.Index, "The token is not within the given list");

            Node<CsToken> start = null;
            Node<CsToken> end = null;

            int bracketCount = 0;
            for (Node<CsToken> tokenNode = methodNameLastToken.Next; tokenNode != null; tokenNode = tokenNode.Next)
            {
                if (tokenNode.Value.CsTokenType == openBracketType)
                {
                    ++bracketCount;
                    if (bracketCount == 1)
                    {
                        start = tokenNode;
                    }
                }
                else if (tokenNode.Value.CsTokenType == closeBracketType)
                {
                    --bracketCount;
                    if (bracketCount == 0)
                    {
                        end = tokenNode;
                        break;
                    }
                }
            }

            if (start == null || end == null)
            {
                return null;
            }

            return new CsTokenList(tokens.MasterList, start, end);
        }
        /// <summary>
        /// Gets the tokens forming the parameter list for a method declaration.
        /// </summary>
        /// <param name="tokens">
        /// The tokens forming the method declaration.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <returns>
        /// Returns the parameter list or null if it cannot be found.
        /// </returns>
        private static CsTokenList GetParameterListTokens(CsTokenList tokens, CsTokenType openBracketType, CsTokenType closeBracketType)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            return GetArgumentListTokens(tokens, tokens.First, openBracketType, closeBracketType);
        }
 /// <summary>
 /// Initializes a new instance of the CsToken class.
 /// </summary>
 /// <param name="text">
 /// The token string.
 /// </param>
 /// <param name="tokenType">
 /// The token type.
 /// </param>
 /// <param name="location">
 /// The location of the token within the code document.
 /// </param>
 /// <param name="parent">
 /// References the parent code part.
 /// </param>
 /// <param name="generated">
 /// True if the token is inside of a block of generated code.
 /// </param>
 internal CsToken(string text, CsTokenType tokenType, CodeLocation location, Reference<ICodePart> parent, bool generated)
     : this(text, tokenType, CsTokenClass.Token, location, parent, generated)
 {
     Param.Ignore(text, tokenType, location, parent, generated);
 }
        /// <summary>
        /// Checks a method or method invocation to ensure that the closing bracket is
        /// on the same line as the last parameter.
        /// </summary>
        /// <param name="element">
        /// The element containing the expression.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens that form the parameter list.
        /// </param>
        /// <param name="openingBracketNode">
        /// The opening bracket.
        /// </param>
        /// <param name="closingBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <param name="arguments">
        /// The arguments to the method.
        /// </param>
        private void CheckMethodClosingBracket(
            CsElement element, CsTokenList parameterListTokens, Node<CsToken> openingBracketNode, CsTokenType closingBracketType, IArgumentList arguments)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.AssertNotNull(openingBracketNode, "openingBracket");
            Param.Ignore(closingBracketType);
            Param.AssertNotNull(arguments, "arguments");

            // Find the closing bracket.
            Node<CsToken> closingBracketNode = null;
            for (Node<CsToken> tokenNode = parameterListTokens.Last; tokenNode != null; tokenNode = tokenNode.Previous)
            {
                if (tokenNode.Value.CsTokenType == closingBracketType)
                {
                    closingBracketNode = tokenNode;
                    break;
                }
            }

            if (closingBracketNode != null)
            {
                if (arguments.Count == 0)
                {
                    // The closing bracket must be on the same line as the opening bracket.
                    if (openingBracketNode.Value.LineNumber != closingBracketNode.Value.LineNumber)
                    {
                        // If the brackets are not on the same line, determine if this is because there are comments
                        // between the brackets.
                        int commentLineSpan = MeasureCommentLinesBetween(openingBracketNode, closingBracketNode, false);

                        if (openingBracketNode.Value.LineNumber + commentLineSpan != closingBracketNode.Value.LineNumber)
                        {
                            this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfOpeningParenthesis);
                        }
                    }
                }
                else
                {
                    // The closing bracket must be on the same line as the end of the last method argument.
                    int lastArgumentEndLine = arguments.Location(arguments.Count - 1).EndPoint.LineNumber;
                    if (lastArgumentEndLine != closingBracketNode.Value.LineNumber)
                    {
                        int commentLineSpan = MeasureCommentLinesBetween(arguments.Tokens(arguments.Count - 1).Last, closingBracketNode, false);

                        if (lastArgumentEndLine + commentLineSpan != closingBracketNode.Value.LineNumber)
                        {
                            this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfLastParameter);
                        }
                    }
                }
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// Gets a token of a specific type.
        /// </summary>
        /// <param name="tokenType">The type of the token to retrieve.</param>
        /// <param name="symbolType">The type of the expected symbol.</param>
        /// <param name="parentReference">Reference to the parent code part.</param>
        /// <param name="tokenParentReference">Reference to the parent of the new token.</param>
        /// <returns>Returns the token.</returns>
        private CsToken GetToken(CsTokenType tokenType, SymbolType symbolType, Reference<ICodePart> parentReference, Reference<ICodePart> tokenParentReference)
        {
            Param.Ignore(tokenType);
            Param.Ignore(symbolType);
            Param.AssertNotNull(parentReference, "parentReference");
            Param.AssertNotNull(tokenParentReference, "tokenParentReference");

            // Determine whether to skip past all standard types, or whether we should stop when we get
            // to one of these types, if that is the type we're looking for.
            SkipSymbols skip = SkipSymbols.All;
            if (symbolType == SymbolType.WhiteSpace)
            {
                skip &= ~SkipSymbols.WhiteSpace;
            }
            else if (symbolType == SymbolType.EndOfLine)
            {
                skip &= ~SkipSymbols.EndOfLine;
            }
            else if (symbolType == SymbolType.SingleLineComment)
            {
                skip &= ~SkipSymbols.SingleLineComment;
            }
            else if (symbolType == SymbolType.MultiLineComment)
            {
                skip &= ~SkipSymbols.MultiLineComment;
            }
            else if (symbolType == SymbolType.PreprocessorDirective)
            {
                skip &= ~SkipSymbols.Preprocessor;
            }
            else if (symbolType == SymbolType.XmlHeaderLine)
            {
                skip &= ~SkipSymbols.XmlHeader;
            }

            // Get the next symbol.
            Symbol symbol = this.GetNextSymbol(symbolType, skip, parentReference);
            this.symbols.Advance();

            // Convert the symbol and return the token.
            return this.ConvertSymbol(symbol, tokenType, tokenParentReference);
        }
Exemplo n.º 20
0
        /// <summary>
        /// Gets a bracket token of a specific type.
        /// </summary>
        /// <param name="tokenType">The type of the token to retrieve.</param>
        /// <param name="symbolType">The type of the symbol.</param>
        /// <param name="parentReference">The parent code unit.</param>
        /// <returns>Returns the token.</returns>
        private Bracket GetBracketToken(CsTokenType tokenType, SymbolType symbolType, Reference<ICodePart> parentReference)
        {
            Param.Ignore(tokenType);
            Param.Ignore(symbolType);
            Param.AssertNotNull(parentReference, "parentReference");

            Debug.Assert(
                tokenType == CsTokenType.OpenParenthesis ||
                tokenType == CsTokenType.CloseParenthesis ||
                tokenType == CsTokenType.OpenSquareBracket ||
                tokenType == CsTokenType.CloseSquareBracket ||
                tokenType == CsTokenType.OpenCurlyBracket ||
                tokenType == CsTokenType.CloseCurlyBracket ||
                tokenType == CsTokenType.OpenAttributeBracket ||
                tokenType == CsTokenType.CloseAttributeBracket ||
                tokenType == CsTokenType.OpenGenericBracket ||
                tokenType == CsTokenType.CloseGenericBracket,
                "The token type is not a bracket.");

            Symbol symbol = this.GetNextSymbol(symbolType, parentReference);
            this.symbols.Advance();

            return new Bracket(symbol.Text, tokenType, symbol.Location, parentReference, this.symbols.Generated);
        }
Exemplo n.º 21
0
        /// <summary>
        /// Checks a method or method invocation to ensure that the closing bracket is
        /// on the same line as the last parameter.
        /// </summary>
        /// <param name="element">
        /// The element containing the expression.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens that form the parameter list.
        /// </param>
        /// <param name="openingBracketNode">
        /// The opening bracket.
        /// </param>
        /// <param name="closingBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <param name="arguments">
        /// The arguments to the method.
        /// </param>
        private void CheckMethodClosingBracket(
            CsElement element, CsTokenList parameterListTokens, Node <CsToken> openingBracketNode, CsTokenType closingBracketType, IArgumentList arguments)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.AssertNotNull(openingBracketNode, "openingBracket");
            Param.Ignore(closingBracketType);
            Param.AssertNotNull(arguments, "arguments");

            // Find the closing bracket.
            Node <CsToken> closingBracketNode = null;

            for (Node <CsToken> tokenNode = parameterListTokens.Last; tokenNode != null; tokenNode = tokenNode.Previous)
            {
                if (tokenNode.Value.CsTokenType == closingBracketType)
                {
                    closingBracketNode = tokenNode;
                    break;
                }
            }

            if (closingBracketNode != null)
            {
                if (arguments.Count == 0)
                {
                    // The closing bracket must be on the same line as the opening bracket.
                    if (openingBracketNode.Value.LineNumber != closingBracketNode.Value.LineNumber)
                    {
                        // If the brackets are not on the same line, determine if this is because there are comments
                        // between the brackets.
                        int commentLineSpan = MeasureCommentLinesBetween(openingBracketNode, closingBracketNode, false);

                        if (openingBracketNode.Value.LineNumber + commentLineSpan != closingBracketNode.Value.LineNumber)
                        {
                            this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfOpeningParenthesis);
                        }
                    }
                }
                else
                {
                    // The closing bracket must be on the same line as the end of the last method argument.
                    int lastArgumentEndLine = arguments.Location(arguments.Count - 1).EndPoint.LineNumber;
                    if (lastArgumentEndLine != closingBracketNode.Value.LineNumber)
                    {
                        int commentLineSpan = MeasureCommentLinesBetween(arguments.Tokens(arguments.Count - 1).Last, closingBracketNode, false);

                        if (lastArgumentEndLine + commentLineSpan != closingBracketNode.Value.LineNumber)
                        {
                            this.AddViolation(element, closingBracketNode.Value.LineNumber, Rules.ClosingParenthesisMustBeOnLineOfLastParameter);
                        }
                    }
                }
            }
        }
Exemplo n.º 22
0
		public static string GetTokenType(CsTokenType pTokenType) {
			if (_typeRef.ContainsKey(pTokenType)) {
				return _typeRef[pTokenType];
			}

			throw new Exception(@"Unknown Typeref: " + pTokenType);
		}
 public AllTokensByTypePrecededByBannedElementIssueLocator(Func<CsElement, IEnumerable<CsToken>> getTokens, CsTokenType tokenTypeToInspect, IEnumerable<CsTokenType> bannedPredecessors)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, bannedPredecessors)
 {
 }
Exemplo n.º 24
0
 public AllTokensByTypePrecededByBannedElementIssueLocator(Func <CsElement, IEnumerable <CsToken> > getTokens, CsTokenType tokenTypeToInspect, params CsTokenType[] bannedPredecessors)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, bannedPredecessors)
 {
 }
Exemplo n.º 25
0
        /*
         * /// <summary>
         * /// Measures the number of lines taken up by comments and attributes before the given word.
         * /// </summary>
         * /// <param name="start">The start token.</param>
         * /// <returns>Returs the number of lines taken up.</returns>
         * private static int MeasureCommentLinesBefore(Node<CsToken> start)
         * {
         *  Param.AssertNotNull(start, "start");
         *
         *  int lineSpan = 0;
         *  int nextLineSpan = -1;
         *  int nextStartLineNumber = -1;
         *
         *  for (Node<CsToken> tokenNode = start.Previous; tokenNode != null; tokenNode = tokenNode.Previous)
         *  {
         *      if (tokenNode.Value.CsTokenType == CsTokenType.SingleLineComment ||
         *          tokenNode.Value.CsTokenType == CsTokenType.MultiLineComment ||
         *          tokenNode.Value.CsTokenType == CsTokenType.Attribute)
         *      {
         *          int itemLineSpan = ParameterPrewordOffset(tokenNode);
         *
         *          if (nextStartLineNumber > 0 && tokenNode.Value.Location.EndPoint.LineNumber == nextStartLineNumber && nextLineSpan > 0)
         *          {
         *              --itemLineSpan;
         *          }
         *
         *          lineSpan += itemLineSpan;
         *          nextLineSpan = itemLineSpan;
         *          nextStartLineNumber = tokenNode.Value.LineNumber;
         *      }
         *  }
         *
         *  return lineSpan;
         * }
         */

        /// <summary>
        /// Gets the tokens forming the argument list for a method call.
        /// </summary>
        /// <param name="tokens">
        /// The tokens forming the method call.
        /// </param>
        /// <param name="methodNameLastToken">
        /// The last token before the argument list begins.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the closing bracket.
        /// </param>
        /// <returns>
        /// Returns the argument list or null if it cannot be found.
        /// </returns>
        private static CsTokenList GetArgumentListTokens(CsTokenList tokens, Node <CsToken> methodNameLastToken, CsTokenType openBracketType, CsTokenType closeBracketType)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(methodNameLastToken, "methodNameLastToken");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            Debug.Assert(methodNameLastToken.Index <= tokens.Last.Index && methodNameLastToken.Index >= tokens.First.Index, "The token is not within the given list");

            Node <CsToken> start = null;
            Node <CsToken> end   = null;

            int bracketCount = 0;

            for (Node <CsToken> tokenNode = methodNameLastToken.Next; tokenNode != null; tokenNode = tokenNode.Next)
            {
                if (tokenNode.Value.CsTokenType == openBracketType)
                {
                    ++bracketCount;
                    if (bracketCount == 1)
                    {
                        start = tokenNode;
                    }
                }
                else if (tokenNode.Value.CsTokenType == closeBracketType)
                {
                    --bracketCount;
                    if (bracketCount == 0)
                    {
                        end = tokenNode;
                        break;
                    }
                }
            }

            if (start == null || end == null)
            {
                return(null);
            }

            return(new CsTokenList(tokens.MasterList, start, end));
        }
Exemplo n.º 26
0
 private CsToken GetToken(CsTokenType tokenType, SymbolType symbolType)
 {
     SkipSymbols all = SkipSymbols.All;
     if (symbolType == SymbolType.WhiteSpace)
     {
         all &= ~SkipSymbols.WhiteSpace;
     }
     else if (symbolType == SymbolType.EndOfLine)
     {
         all &= ~SkipSymbols.EndOfLine;
     }
     else if (symbolType == SymbolType.SingleLineComment)
     {
         all &= ~SkipSymbols.SingleLineComment;
     }
     else if (symbolType == SymbolType.MultiLineComment)
     {
         all &= ~SkipSymbols.MultiLineComment;
     }
     else if (symbolType == SymbolType.PreprocessorDirective)
     {
         all &= ~SkipSymbols.Preprocessor;
     }
     else if (symbolType == SymbolType.XmlHeaderLine)
     {
         all &= ~SkipSymbols.XmlHeader;
     }
     Symbol nextSymbol = this.GetNextSymbol(symbolType, all);
     this.symbols.Advance();
     return this.ConvertSymbol(nextSymbol, tokenType);
 }
Exemplo n.º 27
0
 /// <summary>
 /// Initializes a new instance of the CsToken class.
 /// </summary>
 /// <param name="text">
 /// The token string.
 /// </param>
 /// <param name="tokenType">
 /// The token type.
 /// </param>
 /// <param name="location">
 /// The location of the token within the code document.
 /// </param>
 /// <param name="parent">
 /// References the parent code part.
 /// </param>
 /// <param name="generated">
 /// True if the token is inside of a block of generated code.
 /// </param>
 internal CsToken(string text, CsTokenType tokenType, CodeLocation location, Reference <ICodePart> parent, bool generated)
     : this(text, tokenType, CsTokenClass.Token, location, parent, generated)
 {
     Param.Ignore(text, tokenType, location, parent, generated);
 }
Exemplo n.º 28
0
        /// <summary>
        /// Converts a symbol to the given token type.
        /// </summary>
        /// <param name="symbol">The symbol to convert.</param>
        /// <param name="tokenType">The type of the token to retrieve.</param>
        /// <param name="parentReference">The parent code part.</param>
        /// <returns>Returns the token.</returns>
        private CsToken ConvertSymbol(Symbol symbol, CsTokenType tokenType, Reference<ICodePart> parentReference)
        {
            Param.AssertNotNull(symbol, "symbol");
            Param.Ignore(tokenType);
            Param.AssertNotNull(parentReference, "parentReference");

            // Create the appropriate token based on the type of the symbol.
            if (symbol.SymbolType == SymbolType.WhiteSpace)
            {
                Debug.Assert(tokenType == CsTokenType.WhiteSpace, "The token type is wrong.");
                return new Whitespace(symbol.Text, symbol.Location, parentReference, this.symbols.Generated);
            }
            else if (symbol.SymbolType == SymbolType.Number)
            {
                Debug.Assert(tokenType == CsTokenType.Number, "The token type is wrong.");
                return new Number(symbol.Text, symbol.Location, parentReference, this.symbols.Generated);
            }
            else if (symbol.SymbolType == SymbolType.PreprocessorDirective)
            {
                Debug.Assert(tokenType == CsTokenType.PreprocessorDirective, "The token type is wrong.");
                return this.GetPreprocessorDirectiveToken(symbol, parentReference, this.symbols.Generated);
            }
            else
            {
                // Brackets are created using the GetBracketToken method.
                Debug.Assert(symbol.SymbolType != SymbolType.OpenParenthesis, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.CloseParenthesis, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.OpenSquareBracket, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.CloseSquareBracket, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.OpenCurlyBracket, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.CloseCurlyBracket, "Do not use this method for converting brackets.");
                Debug.Assert(symbol.SymbolType != SymbolType.Attribute, "Do not use this method for converting attributes.");

                return new CsToken(symbol.Text, tokenType, CsTokenClass.Token, symbol.Location, parentReference, this.symbols.Generated);
            }
        }
 public AllTokensByTypeNotPrecededByRequiredElementIssueLocator(Func<CsElement, IEnumerable<CsToken>> getTokens, CsTokenType tokenTypeToInspect, params CsTokenType[] requiredPredecessors)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, requiredPredecessors)
 {
 }
Exemplo n.º 30
0
        /// <summary>
        /// Gets a token of a specific type.
        /// </summary>
        /// <param name="tokenType">The type of the token to retrieve.</param>
        /// <param name="symbolType">The type of the expected symbol.</param>
        /// <param name="parentReference">Reference to the parent code part.</param>
        /// <returns>Returns the token.</returns>
        private CsToken GetToken(CsTokenType tokenType, SymbolType symbolType, Reference<ICodePart> parentReference)
        {
            Param.Ignore(tokenType);
            Param.Ignore(symbolType);
            Param.AssertNotNull(parentReference, "parentReference");

            return this.GetToken(tokenType, symbolType, parentReference, parentReference);
        }
        /// <summary>
        /// Checks the placement and formatting of parameters to a method invocation or a method declaration.
        /// </summary>
        /// <param name="element">
        /// The element.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens that form the parameter list.
        /// </param>
        /// <param name="methodArguments">
        /// The arguments or parameters to the method.
        /// </param>
        /// <param name="methodStartLineNumber">
        /// The line number on which the method begins.
        /// </param>
        /// <param name="openBracketType">
        /// The type of the parameter list opening bracket.
        /// </param>
        /// <param name="closeBracketType">
        /// The type of the parameter list closing bracket.
        /// </param>
        /// <param name="friendlyTypeText">
        /// The text to use for violations.
        /// </param>
        private void CheckParameters(
            CsElement element, 
            CsTokenList parameterListTokens, 
            IArgumentList methodArguments, 
            int methodStartLineNumber, 
            CsTokenType openBracketType, 
            CsTokenType closeBracketType, 
            string friendlyTypeText)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.AssertNotNull(methodArguments, "methodArguments");
            Param.AssertGreaterThanZero(methodStartLineNumber, "methodStartLineNumber");
            Param.Ignore(openBracketType);
            Param.Ignore(closeBracketType);

            Node<CsToken> openingBracketNode = this.CheckMethodOpeningBracket(element, parameterListTokens, openBracketType, friendlyTypeText);

            if (openingBracketNode != null)
            {
                this.CheckMethodClosingBracket(element, parameterListTokens, openingBracketNode, closeBracketType, methodArguments);

                if (methodArguments.Count > 0)
                {
                    this.CheckMethodArgumentList(element, methodArguments, openingBracketNode, methodStartLineNumber, friendlyTypeText);
                }
            }
        }
Exemplo n.º 32
0
        private void CheckDeclarationKeywordOrder(CsElement element)
        {
            Param.AssertNotNull(element, "element");

            int accessModifierIndex = -1;
            int staticIndex         = -1;
            int otherWordIndex      = -1;

            int index = 0;

            foreach (CsToken token in element.Declaration.Tokens)
            {
                CsTokenType type = token.CsTokenType;
                if (type == CsTokenType.Private || type == CsTokenType.Public || type == CsTokenType.Protected || type == CsTokenType.Internal)
                {
                    if (accessModifierIndex == -1)
                    {
                        accessModifierIndex = index++;
                    }
                }
                else if (type == CsTokenType.Static)
                {
                    if (staticIndex == -1)
                    {
                        staticIndex = index++;
                    }
                }
                else if (type != CsTokenType.WhiteSpace && type != CsTokenType.EndOfLine && type != CsTokenType.SingleLineComment && type != CsTokenType.MultiLineComment)
                {
                    if (otherWordIndex == -1)
                    {
                        otherWordIndex = index++;
                    }
                }
            }

            if (accessModifierIndex != -1)
            {
                if (staticIndex > -1 && staticIndex < accessModifierIndex)
                {
                    this.AddViolation(
                        element, Rules.DeclarationKeywordsMustFollowOrder, Strings.AccessModifier, string.Format(CultureInfo.InvariantCulture, "'{0}'", Strings.Static));
                }

                if (otherWordIndex > -1 && otherWordIndex < accessModifierIndex)
                {
                    this.AddViolation(
                        element, Rules.DeclarationKeywordsMustFollowOrder, Strings.AccessModifier, string.Format(CultureInfo.InvariantCulture, "'{0}'", Strings.Other));
                }
            }

            if (staticIndex > -1)
            {
                if (otherWordIndex > -1 && otherWordIndex < staticIndex)
                {
                    this.AddViolation(
                        element,
                        Rules.DeclarationKeywordsMustFollowOrder,
                        string.Format(CultureInfo.InvariantCulture, "'{0}'", Strings.Static),
                        string.Format(CultureInfo.InvariantCulture, "'{0}'", Strings.Other));
                }
            }

            // Check to make sure that 'protected' comes just before 'internal'.
            if (element.Declaration.AccessModifierType == AccessModifierType.ProtectedInternal)
            {
                bool foundProtected = false;
                foreach (CsToken token in element.Declaration.Tokens)
                {
                    if (foundProtected)
                    {
                        if (token.CsTokenType == CsTokenType.Internal)
                        {
                            break;
                        }
                        else if (token.CsTokenType != CsTokenType.WhiteSpace)
                        {
                            this.AddViolation(element, Rules.ProtectedMustComeBeforeInternal);
                            break;
                        }
                    }
                    else
                    {
                        if (token.CsTokenType == CsTokenType.Protected)
                        {
                            foundProtected = true;
                        }
                        else if (token.CsTokenType == CsTokenType.Internal)
                        {
                            this.AddViolation(element, Rules.ProtectedMustComeBeforeInternal);
                            break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Checks a method or method invocation to ensure that the opening bracket is
        /// on the same line as the method declaration.
        /// </summary>
        /// <param name="element">
        /// The element containing the expression.
        /// </param>
        /// <param name="parameterListTokens">
        /// The tokens in the parameter list.
        /// </param>
        /// <param name="openingBracketType">
        /// The type of the bracket that opens the parameter list.
        /// </param>
        /// <param name="textToUseForContainingElement">
        /// The text to use in the violation.
        /// </param>
        /// <returns>
        /// Returns the opening bracket.
        /// </returns>
        private Node<CsToken> CheckMethodOpeningBracket(
            CsElement element, CsTokenList parameterListTokens, CsTokenType openingBracketType, string textToUseForContainingElement)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(parameterListTokens, "parameterListTokens");
            Param.Ignore(openingBracketType);

            // Find the opening bracket.
            Node<CsToken> openingBracketNode = null;

            for (Node<CsToken> tokenNode = parameterListTokens.First; tokenNode != null; tokenNode = tokenNode.Next)
            {
                if (tokenNode.Value.CsTokenType == openingBracketType)
                {
                    openingBracketNode = tokenNode;
                    break;
                }
            }

            CsToken lastWord = null;

            if (openingBracketNode != null)
            {
                // Find the last word before the opening bracket.
                for (Node<CsToken> tokenNode = openingBracketNode.Previous; tokenNode != null; tokenNode = tokenNode.Previous)
                {
                    if (tokenNode.Value.CsTokenType != CsTokenType.WhiteSpace && tokenNode.Value.CsTokenType != CsTokenType.EndOfLine
                        && tokenNode.Value.CsTokenType != CsTokenType.SingleLineComment && tokenNode.Value.CsTokenType != CsTokenType.MultiLineComment)
                    {
                        lastWord = tokenNode.Value;
                        break;
                    }
                }
            }

            if (lastWord != null)
            {
                if (openingBracketNode.Value.LineNumber != lastWord.LineNumber)
                {
                    this.AddViolation(element, openingBracketNode.Value.LineNumber, Rules.OpeningParenthesisMustBeOnDeclarationLine, textToUseForContainingElement);
                }
            }

            return openingBracketNode;
        }
        /// <summary>
        /// Initializes a new instance of the CsToken class.
        /// </summary>
        /// <param name="text">
        /// The token string.
        /// </param>
        /// <param name="tokenType">
        /// The token type.
        /// </param>
        /// <param name="tokenClass">
        /// The token class.
        /// </param>
        /// <param name="location">
        /// The location of the token within the code document.
        /// </param>
        /// <param name="parent">
        /// References the parent code part.
        /// </param>
        /// <param name="generated">
        /// True if the token is inside of a block of generated code.
        /// </param>
        internal CsToken(string text, CsTokenType tokenType, CsTokenClass tokenClass, CodeLocation location, Reference<ICodePart> parent, bool generated)
        {
            Param.AssertNotNull(text, "text");
            Param.Ignore(tokenType);
            Param.Ignore(tokenClass);
            Param.Ignore(location);
            Param.AssertNotNull(parent, "parent");
            Param.Ignore(generated);

            this.text = text;
            this.tokenType = tokenType;
            this.tokenClass = tokenClass;
            this.location = location;
            this.parent = parent;
            this.generated = generated;
        }
Exemplo n.º 35
0
        /// <summary>
        /// Removes whitespace and comments from the beginning and end of the token list.
        /// </summary>
        /// <param name="types">
        /// The types to trim.
        /// </param>
        /// <returns>
        /// Returns the number of tokens that were trimmed from the beginning of the list.
        /// </returns>
        internal int Trim(params CsTokenType[] types)
        {
            Param.Ignore(types);

            if (types == null || types.Length == 0)
            {
                return(0);
            }

            Node <CsToken> begin = null;
            Node <CsToken> end   = null;

            int trimCount = 0;

            // Trim the beginning of the list.
            for (Node <CsToken> tokenNode = this.First; !this.OutOfBounds(tokenNode); tokenNode = tokenNode.Next)
            {
                CsTokenType tokenType = tokenNode.Value.CsTokenType;

                bool match = false;
                for (int i = 0; i < types.Length; ++i)
                {
                    if (tokenType == types[i])
                    {
                        match = true;
                        break;
                    }
                }

                if (!match)
                {
                    begin = tokenNode;
                    break;
                }

                ++trimCount;
            }

            // Trim the end of the list.
            for (Node <CsToken> tokenNode = this.Last; !this.OutOfBounds(tokenNode); tokenNode = tokenNode.Previous)
            {
                CsTokenType tokenType = tokenNode.Value.CsTokenType;

                bool match = false;
                for (int i = 0; i < types.Length; ++i)
                {
                    if (tokenType == types[i])
                    {
                        match = true;
                        break;
                    }
                }

                if (!match)
                {
                    end = tokenNode;
                    break;
                }
            }

            this.First = begin;
            this.Last  = end;

            return(trimCount);
        }
 public AllTokensByTypeNotPrecededByRequiredElementIssueLocator(Func <CsElement, IEnumerable <CsToken> > getTokens, CsTokenType tokenTypeToInspect, IEnumerable <CsTokenType> requiredPredecessors)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, requiredPredecessors)
 {
 }
Exemplo n.º 37
0
 private CsToken ConvertSymbol(Symbol symbol, CsTokenType tokenType)
 {
     if (symbol.SymbolType == SymbolType.WhiteSpace)
     {
         return new Whitespace(symbol.Text, symbol.Location, this.symbols.Generated);
     }
     if (symbol.SymbolType == SymbolType.Number)
     {
         return new Microsoft.StyleCop.CSharp.Number(symbol.Text, symbol.Location, this.symbols.Generated);
     }
     if (symbol.SymbolType == SymbolType.PreprocessorDirective)
     {
         return this.GetPreprocessorDirectiveToken(symbol, this.symbols.Generated);
     }
     return new CsToken(symbol.Text, tokenType, CsTokenClass.Token, symbol.Location, this.symbols.Generated);
 }
 public AllTokensByTypeFollowedByBannedElementIssueLocator(Func<CsElement, IEnumerable<CsToken>> getTokens, CsTokenType tokenTypeToInspect, params CsTokenType[] bannedFollowers)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, bannedFollowers)
 {
 }
Exemplo n.º 39
0
 private Bracket GetBracketToken(CsTokenType tokenType, SymbolType symbolType)
 {
     Symbol nextSymbol = this.GetNextSymbol(symbolType);
     this.symbols.Advance();
     return new Bracket(nextSymbol.Text, tokenType, nextSymbol.Location, this.symbols.Generated);
 }
Exemplo n.º 40
0
		private static CsTokenType convertToken(CsTokenType pInToken) {
			switch (pInToken) {
				case CsTokenType.tkPLUS_EQ:
					return CsTokenType.tkPLUS;

				case CsTokenType.tkMINUS_EQ:
					return CsTokenType.tkMINUS;

				case CsTokenType.tkDIV_EQ:
					return CsTokenType.tkDIV;

				case CsTokenType.tkMUL_EQ:
					return CsTokenType.tkSTAR;

				case CsTokenType.tkMOD_EQ:
					return CsTokenType.tkMOD;

				default:
					throw new Exception();
			}
		}
Exemplo n.º 41
0
 public AllTokensByTypeFollowedByBannedElementIssueLocator(Func <CsElement, IEnumerable <CsToken> > getTokens, CsTokenType tokenTypeToInspect, IEnumerable <CsTokenType> bannedFollowers)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, bannedFollowers)
 {
 }
Exemplo n.º 42
0
 public AllTokensByTypeNotFollowedByRequiredElementIssueLocator(Func <CsElement, IEnumerable <CsToken> > getTokens, CsTokenType tokenTypeToInspect, params CsTokenType[] requiredFollowers)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, requiredFollowers)
 {
 }
 public AllTokensByTypeNotFollowedByRequiredElementIssueLocator(Func<CsElement, IEnumerable<CsToken>> getTokens, CsTokenType tokenTypeToInspect, Func<CsToken, bool> isRequiredFollower)
     : base(getTokens, (token, violation) => token.CsTokenType == tokenTypeToInspect, isRequiredFollower)
 {
 }