/// <summary>
        /// Initializes a new instance of the ConstructorInitializerStatement class.
        /// </summary>
        /// <param name="tokens">The list of tokens that form the statement.</param>
        /// <param name="expression">The expression within this statement.</param>
        internal ConstructorInitializerStatement(CsTokenList tokens, MethodInvocationExpression expression)
            : base(StatementType.ConstructorInitializer, tokens)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(expression, "expression");

            this.expression = expression;
            this.AddExpression(expression);
        }
Esempio n. 2
0
        /// <summary>
        /// Initializes a new instance of the Constructor class.
        /// </summary>
        /// <param name="document">The documenent that contains the element.</param>
        /// <param name="parent">The parent of the element.</param>
        /// <param name="header">The Xml header for this element.</param>
        /// <param name="attributes">The list of attributes attached to this element.</param>
        /// <param name="declaration">The declaration code for this element.</param>
        /// <param name="parameters">The parameters to the constructor.</param>
        /// <param name="initializerExpression">The constructor initializer, if there is one.</param>
        /// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
        /// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
        internal Constructor(
            CsDocument document,
            CsElement parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            IList<Parameter> parameters,
            MethodInvocationExpression initializerExpression,
            bool unsafeCode,
            bool generated)
            : base(document,
            parent,
            ElementType.Constructor,
            "constructor " + declaration.Name,
            header,
            attributes,
            declaration,
            unsafeCode,
            generated)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parent, "parent");
            Param.Ignore(header);
            Param.Ignore(attributes);
            Param.AssertNotNull(declaration, "declaration");
            Param.AssertNotNull(parameters, "parameters");
            Param.Ignore(initializerExpression);
            Param.Ignore(unsafeCode);
            Param.Ignore(generated);

            // Static constructors are always public.
            if (this.Declaration.ContainsModifier(CsTokenType.Static))
            {
                this.Declaration.AccessModifierType = AccessModifierType.Public;
            }

            this.parameters = parameters;
            Debug.Assert(parameters.IsReadOnly, "The parameters collection should be read-only.");

            // Add the qualifications
            this.QualifiedName = CodeParser.AddQualifications(this.parameters, this.QualifiedName);

            // If there is an initializer expression, add it to the statement list for this constructor.
            if (initializerExpression != null)
            {
                this.initializer = initializerExpression;

                ConstructorInitializerStatement initializerStatement = new ConstructorInitializerStatement(
                    initializerExpression.Tokens, initializerExpression);
                this.AddStatement(initializerStatement);
            }
        }
        /// <summary>
        /// Extracts the CheckID for the rule being suppressed, from the given Code Analysis SuppressMessage attribute expression.
        /// </summary>
        /// <param name="codeAnalysisAttributeExpression">The expression to parse.</param>
        /// <param name="ruleId">Returns the rule ID.</param>
        /// <param name="ruleName">Returns the rule name.</param>
        /// <param name="ruleNamespace">Returns the namespace that contains the rule.</param>
        /// <returns>Returns true if the ID, name, and namespace were successfully extracted from the suppression.</returns>
        private static bool TryCrackCodeAnalysisSuppression(MethodInvocationExpression codeAnalysisAttributeExpression, out string ruleId, out string ruleName, out string ruleNamespace)
        {
            Param.AssertNotNull(codeAnalysisAttributeExpression, "codeAnalysisAttributeExpression");

            // Initialize all out fields to null.
            ruleId = ruleName = ruleNamespace = null;

            if (codeAnalysisAttributeExpression.Arguments != null && codeAnalysisAttributeExpression.Arguments.Count >= 2)
            {
                // The rule namespace sits in the first argument.
                ruleNamespace = ExtractStringFromAttributeExpression(codeAnalysisAttributeExpression.Arguments[0].Expression);
                if (string.IsNullOrEmpty(ruleNamespace))
                {
                    return false;
                }

                // The checkID and rule name sit in the second argument.
                string nameAndId = ExtractStringFromAttributeExpression(codeAnalysisAttributeExpression.Arguments[1].Expression);
                if (string.IsNullOrEmpty(nameAndId))
                {
                    return false;
                }

                // When the nameAndId field just contains a *, this means to supress all rules in the given namespace.
                if (nameAndId == "*")
                {
                    ruleId = "*";
                    return true;
                }

                // Split the rule name and ID.
                int separatorIndex = nameAndId.IndexOf(':');
                if (separatorIndex == -1)
                {
                    return false;
                }

                ruleId = nameAndId.Substring(0, separatorIndex);
                ruleName = nameAndId.Substring(separatorIndex + 1, nameAndId.Length - separatorIndex - 1);

                return ruleId.Length > 0 && ruleName.Length > 0;
            }

            return false;
        }
        /// <summary>
        /// Reads a method access expression.
        /// </summary>
        /// <param name="methodName">The name of the method being called.</param>
        /// <param name="previousPrecedence">The precedence of the previous expression.</param>
        /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
        /// <returns>Returns the expression.</returns>
        private MethodInvocationExpression GetMethodInvocationExpression(
            Expression methodName, ExpressionPrecedence previousPrecedence, bool unsafeCode)
        {
            Param.AssertNotNull(methodName, "methodName");
            Param.Ignore(previousPrecedence);
            Param.Ignore(unsafeCode);

            MethodInvocationExpression expression = null;
            if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.Primary))
            {
                var expressionReference = new Reference<ICodePart>();

                // The next symbol will be the opening parenthesis.
                Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis, expressionReference);
                Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis);

                // Get the argument list now.
                IList<Argument> argumentList = this.GetArgumentList(SymbolType.CloseParenthesis, expressionReference, unsafeCode);

                // Get the closing parenthesis.
                Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis, expressionReference);
                Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis);

                openParenthesis.MatchingBracketNode = closeParenthesisNode;
                closeParenthesis.MatchingBracketNode = openParenthesisNode;

                // Pull out the first token from the method name.
                Debug.Assert(methodName.Tokens.First != null, "The method name should not be empty");
                Node<CsToken> firstTokenNode = methodName.Tokens.First;

                // Create the token list for the method invocation expression.
                CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);

                // Create and return the expression.
                expression = new MethodInvocationExpression(partialTokens, methodName, argumentList);
                expressionReference.Target = expression;
            }

            return expression;
        }
Esempio n. 5
0
 private MethodInvocationExpression GetMethodInvocationExpression(Expression methodName, ExpressionPrecedence previousPrecedence, bool unsafeCode)
 {
     MethodInvocationExpression expression = null;
     if (CheckPrecedence(previousPrecedence, ExpressionPrecedence.Primary))
     {
         Bracket bracketToken = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis);
         Microsoft.StyleCop.Node<CsToken> node = this.tokens.InsertLast(bracketToken);
         IList<Expression> argumentList = this.GetArgumentList(SymbolType.CloseParenthesis, unsafeCode);
         Bracket item = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis);
         Microsoft.StyleCop.Node<CsToken> node2 = this.tokens.InsertLast(item);
         bracketToken.MatchingBracketNode = node2;
         item.MatchingBracketNode = node;
         Microsoft.StyleCop.Node<CsToken> first = methodName.Tokens.First;
         CsTokenList tokens = new CsTokenList(this.tokens, first, this.tokens.Last);
         expression = new MethodInvocationExpression(tokens, methodName, argumentList);
     }
     return expression;
 }
Esempio n. 6
0
 private static bool TryCrackCodeAnalysisSuppression(MethodInvocationExpression codeAnalysisAttributeExpression, out string ruleId, out string ruleName, out string ruleNamespace)
 {
     string str2;
     ruleNamespace = (string) (str2 = null);
     ruleId = ruleName = str2;
     if ((codeAnalysisAttributeExpression.Arguments == null) || (codeAnalysisAttributeExpression.Arguments.Count < 2))
     {
         return false;
     }
     ruleNamespace = ExtractStringFromAttributeExpression(codeAnalysisAttributeExpression.Arguments[0]);
     if (string.IsNullOrEmpty(ruleNamespace))
     {
         return false;
     }
     string str = ExtractStringFromAttributeExpression(codeAnalysisAttributeExpression.Arguments[1]);
     if (string.IsNullOrEmpty(str))
     {
         return false;
     }
     int index = str.IndexOf(':');
     if (index == -1)
     {
         return false;
     }
     ruleId = str.Substring(0, index);
     ruleName = str.Substring(index + 1, (str.Length - index) - 1);
     return ((ruleId.Length > 0) && (ruleName.Length > 0));
 }
 private static bool IsSuppressMessage(MethodInvocationExpression expression)
 {
     Microsoft.StyleCop.Node<CsToken> first = expression.Name.Tokens.First;
     if (first != null)
     {
         if (first.Value.Text.Equals("SuppressMessage", StringComparison.Ordinal))
         {
             return true;
         }
         if (first.Value.Text.Equals("System"))
         {
             return expression.Name.Tokens.MatchTokens(new string[] { "System", ".", "Diagnostics", ".", "CodeAnalysis", ".", "SuppressMessage" });
         }
     }
     return false;
 }
 private void CheckDebugFailMessage(CsElement element, MethodInvocationExpression debugFailMethodCall)
 {
     Expression expression = null;
     foreach (Expression expression2 in debugFailMethodCall.Arguments)
     {
         expression = expression2;
         break;
     }
     if ((expression == null) || (expression.Tokens.First == null))
     {
         base.AddViolation(element, debugFailMethodCall.LineNumber, Microsoft.StyleCop.CSharp.Rules.DebugFailMustProvideMessageText, new object[0]);
     }
     else if ((expression.Tokens.First.Value.CsTokenType == CsTokenType.String) && IsEmptyString(expression.Tokens.First.Value.Text))
     {
         base.AddViolation(element, debugFailMethodCall.LineNumber, Microsoft.StyleCop.CSharp.Rules.DebugFailMustProvideMessageText, new object[0]);
     }
 }
 private void CheckCodeAnalysisSuppressionForJustification(CsElement element, MethodInvocationExpression suppression)
 {
     bool flag = false;
     foreach (Expression expression in suppression.Arguments)
     {
         if (expression.ExpressionType == ExpressionType.Assignment)
         {
             AssignmentExpression expression2 = (AssignmentExpression) expression;
             if (expression2.LeftHandSide.Tokens.First.Value.Text.Equals("Justification", StringComparison.Ordinal))
             {
                 Microsoft.StyleCop.Node<CsToken> first = expression2.RightHandSide.Tokens.First;
                 if (((first != null) && (first.Value.CsTokenType == CsTokenType.String)) && ((first.Value.Text != null) && !IsEmptyString(first.Value.Text)))
                 {
                     flag = true;
                     break;
                 }
             }
         }
     }
     if (!flag)
     {
         base.AddViolation(element, suppression.LineNumber, Microsoft.StyleCop.CSharp.Rules.CodeAnalysisSuppressionMustHaveJustification, new object[0]);
     }
 }
        /// <summary>
        /// Checks the given call into Debug.Fail to ensure that it contains a valid debug message.
        /// </summary>
        /// <param name="element">The parent element.</param>
        /// <param name="debugFailMethodCall">The call to Debug.Fail.</param>
        private void CheckDebugFailMessage(CsElement element, MethodInvocationExpression debugFailMethodCall)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(debugFailMethodCall, "debugFailMethodCall");

            // Extract the first argument.
            Argument firstArgument = null;
            foreach (Argument argument in debugFailMethodCall.Arguments)
            {
                firstArgument = argument;
                break;
            }

            if (firstArgument == null || firstArgument.Tokens.First == null)
            {
                // There is no message argument or the message argument is empty.
                this.AddViolation(element, debugFailMethodCall.LineNumber, Rules.DebugFailMustProvideMessageText);
            }
            else if (firstArgument.Tokens.First.Value.CsTokenType == CsTokenType.String &&
                IsEmptyString(firstArgument.Tokens.First.Value.Text))
            {
                // The message argument contains an empty string.
                this.AddViolation(element, debugFailMethodCall.LineNumber, Rules.DebugFailMustProvideMessageText);
            }
        }
        /// <summary>
        /// Checks the given call into Debug.Assert to ensure that it contains a valid debug message.
        /// </summary>
        /// <param name="element">The parent element.</param>
        /// <param name="debugAssertMethodCall">The call to Debug.Assert.</param>
        private void CheckDebugAssertMessage(CsElement element, MethodInvocationExpression debugAssertMethodCall)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(debugAssertMethodCall, "debugAssertMethodCall");

            // Extract the second argument.
            Argument secondArgument = null;
            if (debugAssertMethodCall.Arguments.Count >= 2)
            {
                secondArgument = debugAssertMethodCall.Arguments[1];
            }

            if (secondArgument == null || secondArgument.Tokens.First == null)
            {
                // There is no message argument or the message argument is empty.
                this.AddViolation(element, debugAssertMethodCall.LineNumber, Rules.DebugAssertMustProvideMessageText);
            }
            else if (secondArgument.Tokens.First.Value.CsTokenType == CsTokenType.String &&
                IsEmptyString(secondArgument.Tokens.First.Value.Text))
            {
                // The message argument contains an empty string.
                this.AddViolation(element, debugAssertMethodCall.LineNumber, Rules.DebugAssertMustProvideMessageText);
            }
        }
        /// <summary>
        /// Checks the given code analysis suppression call to ensure that it contains a justifiction parameter.
        /// </summary>
        /// <param name="element">The element that contains the suppression attribute.</param>
        /// <param name="suppression">The suppression to check.</param>
        private void CheckCodeAnalysisSuppressionForJustification(CsElement element, MethodInvocationExpression suppression)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(suppression, "suppression");

            bool justifiction = false;
            foreach (Argument argument in suppression.Arguments)
            {
                if (argument.Expression.ExpressionType == ExpressionType.Assignment)
                {
                    AssignmentExpression assignmentExpression = (AssignmentExpression)argument.Expression;
                    if (assignmentExpression.LeftHandSide.Tokens.First.Value.Text.Equals("Justification", StringComparison.Ordinal))
                    {
                        Node<CsToken> rightSideTokenNode = assignmentExpression.RightHandSide.Tokens.First;
                        if (rightSideTokenNode != null &&
                            rightSideTokenNode.Value.CsTokenType == CsTokenType.String &&
                            rightSideTokenNode.Value.Text != null &&
                            !IsEmptyString(rightSideTokenNode.Value.Text))
                        {
                            justifiction = true;
                            break;
                        }
                    }
                }
            }

            if (!justifiction)
            {
                this.AddViolation(element, suppression.LineNumber, Rules.CodeAnalysisSuppressionMustHaveJustification);
            }
        }
        /// <summary>
        /// Determines whether the given method invocation expression contains a code analysis SuppressMessage call.
        /// </summary>
        /// <param name="expression">The expression.</param>
        /// <returns>Returns true if the method is SuppressMessage.</returns>
        private static bool IsSuppressMessage(MethodInvocationExpression expression)
        {
            Param.AssertNotNull(expression, "expression");

            Node<CsToken> first = expression.Name.Tokens.First;
            if (first != null)
            {
                if (first.Value.Text.Equals("SuppressMessage", StringComparison.Ordinal))
                {
                    return true;
                }
                else if (first.Value.Text.Equals("System"))
                {
                    return expression.Name.Tokens.MatchTokens("System", ".", "Diagnostics", ".", "CodeAnalysis", ".", "SuppressMessage");
                }
            }

            return false;
        }
 internal ConstructorInitializerStatement(CsTokenList tokens, MethodInvocationExpression expression)
     : base(StatementType.ConstructorInitializer, tokens)
 {
     this.expression = expression;
     base.AddExpression(expression);
 }
        /// <summary>
        /// Checks a method invocation expression to make that the parameters are positioned correctly.
        /// </summary>
        /// <param name="element">The element containing the expression.</param>
        /// <param name="expression">The expression to check.</param>
        private void CheckMethodInvocationParameters(CsElement element, MethodInvocationExpression expression)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(expression, "expression");

            if (expression.Tokens.First != null && !expression.Tokens.First.Value.Generated)
            {
                ArgumentList argumentList = new ArgumentList(expression.Arguments);
                CsTokenList argumentListTokens = GetArgumentListTokens(expression.Tokens, expression.Name.Tokens.Last, CsTokenType.OpenParenthesis, CsTokenType.CloseParenthesis);

                if (argumentListTokens != null)
                {
                    this.CheckParameters(element, argumentListTokens, argumentList, expression.LineNumber, CsTokenType.OpenParenthesis, CsTokenType.CloseParenthesis);
                }
            }
        }