예제 #1
0
 internal CatchStatement(CsTokenList tokens, Microsoft.StyleCop.CSharp.TryStatement tryStatement, Expression classExpression, BlockStatement embeddedStatement)
     : base(StatementType.Catch, tokens)
 {
     this.tryStatement = tryStatement;
     this.catchExpression = classExpression;
     this.embeddedStatement = embeddedStatement;
     if (classExpression != null)
     {
         base.AddExpression(classExpression);
         if (classExpression != null)
         {
             if (classExpression.ExpressionType == ExpressionType.Literal)
             {
                 this.classType = ((LiteralExpression) classExpression).Token as TypeToken;
             }
             else if (classExpression.ExpressionType == ExpressionType.VariableDeclaration)
             {
                 VariableDeclarationExpression expression = (VariableDeclarationExpression) classExpression;
                 this.classType = expression.Type;
                 foreach (VariableDeclaratorExpression expression2 in expression.Declarators)
                 {
                     this.identifier = expression2.Identifier.Text;
                     break;
                 }
             }
         }
     }
     base.AddStatement(embeddedStatement);
 }
예제 #2
0
        /// <summary>
        /// Initializes a new instance of the Field 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="fieldType">The type of the field.</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 Field(
            CsDocument document,
            CsElement parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            TypeToken fieldType,
            bool unsafeCode,
            bool generated)
            : base(document, 
            parent, 
            ElementType.Field, 
            "field " + 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(fieldType, "fieldType");
            Param.Ignore(unsafeCode);
            Param.Ignore(generated);

            this.type = fieldType;

            // Determine whether the item is const or readonly.
            this.isConst = this.Declaration.ContainsModifier(CsTokenType.Const);
            this.isReadOnly = this.Declaration.ContainsModifier(CsTokenType.Readonly);
        }
예제 #3
0
 internal Method(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, IList<Parameter> parameters, ICollection<TypeParameterConstraintClause> typeConstraints, bool unsafeCode, bool generated)
     : base(document, parent, ElementType.Method, "method " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
 {
     this.returnType = returnType;
     this.parameters = parameters;
     this.typeConstraints = typeConstraints;
     if ((this.parameters.Count > 0) && base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Static }))
     {
         foreach (Parameter parameter in this.parameters)
         {
             if ((parameter.Modifiers & ParameterModifiers.This) != ParameterModifiers.None)
             {
                 this.extensionMethod = true;
             }
             break;
         }
     }
     base.QualifiedName = CodeParser.AddQualifications(this.parameters, base.QualifiedName);
     if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
     {
         base.Declaration.AccessModifierType = AccessModifierType.Public;
     }
     if (typeConstraints != null)
     {
         foreach (TypeParameterConstraintClause clause in typeConstraints)
         {
             clause.ParentElement = this;
         }
     }
 }
예제 #4
0
 internal Field(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken fieldType, bool unsafeCode, bool generated)
     : base(document, parent, ElementType.Field, "field " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
 {
     this.type = fieldType;
     this.isConst = base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Const });
     this.isReadOnly = base.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Readonly });
 }
        /// <summary>
        /// Initializes a new instance of the GenericTypeParameter class.
        /// </summary>
        /// <param name="type">The generic type parameter.</param>
        /// <param name="modifiers">Optional modifiers.</param>
        internal GenericTypeParameter(TypeToken type, ParameterModifiers modifiers)
        {
            Param.AssertNotNull(type, "type");
            Param.Ignore(modifiers);

            this.type = type;
            this.modifiers = modifiers;
        }
예제 #6
0
 internal Variable(TypeToken type, string name, VariableModifiers modifiers, CodePoint location, bool generated)
 {
     this.type = type;
     this.name = name;
     this.modifiers = modifiers;
     this.location = location;
     this.generated = generated;
 }
예제 #7
0
 internal IsExpression(CsTokenList tokens, Expression value, LiteralExpression type)
     : base(ExpressionType.Is, tokens)
 {
     this.value = value;
     this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
     base.AddExpression(value);
     base.AddExpression(type);
 }
예제 #8
0
 internal Property(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, bool unsafeCode, bool generated)
     : base(document, parent, ElementType.Property, "property " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
 {
     this.returnType = returnType;
     if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
     {
         base.Declaration.AccessModifierType = AccessModifierType.Public;
     }
 }
예제 #9
0
 internal Parameter(TypeToken type, string name, ParameterModifiers modifiers, CodeLocation location, CsTokenList tokens, bool generated)
 {
     this.type = type;
     this.name = name;
     this.modifiers = modifiers;
     this.location = location;
     this.tokens = tokens;
     this.generated = generated;
 }
        /// <summary>
        /// Initializes a new instance of the DefaultValueExpression class.
        /// </summary>
        /// <param name="tokens">The list of tokens that form the expression.</param>
        /// <param name="type">The type to obtain the default value of.</param>
        internal DefaultValueExpression(CsTokenList tokens, LiteralExpression type)
            : base(ExpressionType.DefaultValue, tokens)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(type, "type");

            this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
            this.AddExpression(type);
        }
예제 #11
0
 internal Indexer(CsDocument document, CsElement parent, XmlHeader header, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes, Declaration declaration, TypeToken returnType, IList<Parameter> parameters, bool unsafeCode, bool generated)
     : base(document, parent, ElementType.Indexer, "indexer " + declaration.Name, header, attributes, declaration, unsafeCode, generated)
 {
     this.returnType = returnType;
     this.parameters = parameters;
     base.QualifiedName = CodeParser.AddQualifications(this.parameters, base.QualifiedName);
     if ((base.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1) && !base.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
     {
         base.Declaration.AccessModifierType = AccessModifierType.Public;
     }
 }
 internal VariableDeclarationExpression(CsTokenList tokens, LiteralExpression type, ICollection<VariableDeclaratorExpression> declarators)
     : base(ExpressionType.VariableDeclaration, tokens)
 {
     this.declarators = declarators;
     base.AddExpression(type);
     this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
     foreach (VariableDeclaratorExpression expression in declarators)
     {
         base.AddExpression(expression);
         expression.ParentVariable = this;
     }
 }
예제 #13
0
        /// <summary>
        /// Initializes a new instance of the Delegate class.
        /// </summary>
        /// <param name="document">The document 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="returnType">The return type.</param>
        /// <param name="parameters">The parameters to the delegate.</param>
        /// <param name="typeConstraints">The list of type constraints on the element.</param>
        /// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
        /// <param name="generated">Indicates whether this is generated code.</param>
        internal Delegate(
            CsDocument document,
            CsElement parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            TypeToken returnType,
            IList<Parameter> parameters,
            ICollection<TypeParameterConstraintClause> typeConstraints,
            bool unsafeCode,
            bool generated)
            : base(document,
            parent,
            ElementType.Delegate, 
            "delegate " + 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(returnType, "returnType");
            Param.AssertNotNull(parameters, "parameters");
            Param.Ignore(typeConstraints);
            Param.Ignore(unsafeCode);
            Param.Ignore(generated);

            this.returnType = returnType;
            this.typeConstraints = typeConstraints;
            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);

            // Set the parent of the type constraint clauses.
            if (typeConstraints != null)
            {
                Debug.Assert(typeConstraints.IsReadOnly, "The collection of type constraints should be read-only.");

                foreach (TypeParameterConstraintClause constraint in typeConstraints)
                {
                    constraint.ParentElement = this;
                }
            }
        }
예제 #14
0
        /// <summary>
        /// Initializes a new instance of the AsExpression class.
        /// </summary>
        /// <param name="tokens">The list of tokens that form the expression.</param>
        /// <param name="value">The value to convert.</param>
        /// <param name="type">The type of the conversion.</param>
        internal AsExpression(CsTokenList tokens, Expression value, LiteralExpression type)
            : base(ExpressionType.As, tokens)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(value, "value");
            Param.AssertNotNull(type, "type");

            this.value = value;
            this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);

            this.AddExpression(value);
            this.AddExpression(type);
        }
예제 #15
0
        /// <summary>
        /// Initializes a new instance of the CastExpression class.
        /// </summary>
        /// <param name="tokens">The list of tokens that form the expression.</param>
        /// <param name="type">The cast type.</param>
        /// <param name="castedExpression">The expression being casted.</param>
        internal CastExpression(CsTokenList tokens, LiteralExpression type, Expression castedExpression)
            : base(ExpressionType.Cast, tokens)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(type, "type");
            Param.AssertNotNull(castedExpression, "castedExpression");

            this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
            this.castedExpression = castedExpression;

            this.AddExpression(type);
            this.AddExpression(castedExpression);
        }
예제 #16
0
        /// <summary>
        /// Initializes a new instance of the Variable class.
        /// </summary>
        /// <param name="type">The type of the variable.</param>
        /// <param name="name">The name of the variable.</param>
        /// <param name="modifiers">Modifers applied to this variable.</param>
        /// <param name="location">The location of the variable.</param>
        /// <param name="parent">The parent code part.</param>
        /// <param name="generated">Indicates whethre the variable is located within a block of generated code.</param>
        internal Variable(TypeToken type, string name, VariableModifiers modifiers, CodeLocation location, Reference<ICodePart> parent, bool generated)
        {
            Param.Ignore(type);
            Param.AssertValidString(name, "name");
            Param.Ignore(modifiers);
            Param.AssertNotNull(location, "location");
            Param.AssertNotNull(parent, "parent");
            Param.Ignore(generated);

            this.type = type;
            this.name = name;
            this.modifiers = modifiers;
            this.location = location;
            this.parent = parent;
            this.generated = generated;
        }
예제 #17
0
        /// <summary>
        /// Initializes a new instance of the Indexer 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="returnType">The return type of the indexer.</param>
        /// <param name="parameters">The parameters to the indexer.</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 Indexer(
            CsDocument document,
            CsElement parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            TypeToken returnType,
            IList<Parameter> parameters,
            bool unsafeCode,
            bool generated)
            : base(document, 
            parent, 
            ElementType.Indexer, 
            "indexer " + 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.Ignore(returnType);
            Param.AssertNotNull(parameters, "parameters");
            Param.Ignore(unsafeCode);
            Param.Ignore(generated);

            this.returnType = returnType;
            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 this is an explicit interface member implementation and our access modifier
            // is currently set to private because we don't have one, then it should be public instead.
            if (this.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1 &&
                !this.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
            {
                this.Declaration.AccessModifierType = AccessModifierType.Public;
            }
        }
예제 #18
0
        /// <summary>
        /// Initializes a new instance of the Property 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="returnType">The property return type.</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 Property(
            CsDocument document,
            CsElement parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            TypeToken returnType,
            bool unsafeCode,
            bool generated)
            : base(document, 
            parent, 
            ElementType.Property, 
            "property " + 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(returnType, "returnType");
            Param.Ignore(unsafeCode);
            Param.Ignore(generated);

            this.returnType = returnType;

            // If this is an explicit interface member implementation and our access modifier
            // is currently set to private because we don't have one, then it should be public instead.
            if (this.Declaration.Name.IndexOf(".", StringComparison.Ordinal) > -1 &&
                !this.Declaration.Name.StartsWith("this.", StringComparison.Ordinal))
            {
                this.Declaration.AccessModifierType = AccessModifierType.Public;
            }
        }
        /// <summary>
        /// Initializes a new instance of the VariableDeclarationExpression class.
        /// </summary>
        /// <param name="tokens">The list of tokens that form the statement.</param>
        /// <param name="type">The type of the variable or variables being declared.</param>
        /// <param name="declarators">The list of declarators in the expression.</param>
        internal VariableDeclarationExpression(
            CsTokenList tokens, 
            LiteralExpression type, 
            ICollection<VariableDeclaratorExpression> declarators)
            : base(ExpressionType.VariableDeclaration, tokens)
        {
            Param.AssertNotNull(tokens, "tokens");
            Param.AssertNotNull(type, "type");
            Param.AssertNotNull(declarators, "declarators");

            this.declarators = declarators;

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

            this.AddExpression(type);
            this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);

            foreach (VariableDeclaratorExpression expression in declarators)
            {
                this.AddExpression(expression);
                expression.ParentVariable = this;
            }
        }
예제 #20
0
 private IList<VariableDeclaratorExpression> ParseFieldDeclarators(bool unsafeCode, TypeToken fieldType)
 {
     List<VariableDeclaratorExpression> list = new List<VariableDeclaratorExpression>();
     Symbol nextSymbol = this.GetNextSymbol();
     while (nextSymbol.SymbolType != SymbolType.Semicolon)
     {
         CsToken elementNameToken = this.GetElementNameToken(unsafeCode, true);
         Microsoft.StyleCop.Node<CsToken> firstItemNode = this.tokens.InsertLast(elementNameToken);
         Expression initializer = null;
         if (this.GetNextSymbol().SymbolType == SymbolType.Equals)
         {
             this.tokens.Add(this.GetOperatorToken(OperatorType.Equals));
             if (this.GetNextSymbol().SymbolType == SymbolType.OpenCurlyBracket)
             {
                 if ((fieldType.Text == "var") || (((fieldType.Text != "Array") && (fieldType.Text != "System.Array")) && !fieldType.Text.Contains("[")))
                 {
                     initializer = this.GetAnonymousTypeInitializerExpression(unsafeCode);
                 }
                 else
                 {
                     initializer = this.GetArrayInitializerExpression(unsafeCode);
                 }
             }
             else
             {
                 initializer = this.GetNextExpression(ExpressionPrecedence.None, unsafeCode);
             }
             if (initializer == null)
             {
                 throw this.CreateSyntaxException();
             }
         }
         list.Add(new VariableDeclaratorExpression(new CsTokenList(this.tokens, firstItemNode, this.tokens.Last), new LiteralExpression(this.tokens, firstItemNode), initializer));
         nextSymbol = this.GetNextSymbol();
         if (nextSymbol.SymbolType == SymbolType.Comma)
         {
             this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma));
             nextSymbol = this.GetNextSymbol();
         }
     }
     return list.ToArray();
 }
예제 #21
0
        /// <summary>
        /// Fills in the details of the set accessor.
        /// </summary>
        /// <param name="parent">The parent of the accessor.</param>
        private void FillSetAccessorDetails(CsElement parent)
        {
            Param.AssertNotNull(parent, "parent");

            var accessorReference = new Reference<ICodePart>(this);

            Property property = parent as Property;
            if (property != null)
            {
                // Set accessors on properties do not have a return type but have an
                // implied input parameter.
                this.returnType = CreateVoidTypeToken(accessorReference);

                this.parameters = new Parameter[]
                    {
                        new Parameter(
                            property.ReturnType,
                            "value",
                            accessorReference,
                            ParameterModifiers.None,
                            null,
                            CodeLocation.Empty,
                            null,
                            property.ReturnType.Generated)
                    };
            }
            else
            {
                // Set accessors on indexers do not have a return type but, but have the input
                // parameters of the parent indexer.
                Indexer indexer = (Indexer)parent as Indexer;

                this.returnType = CreateVoidTypeToken(accessorReference);

                Parameter[] tempParameters = new Parameter[indexer.Parameters.Count + 1];
                int i = 0;
                foreach (Parameter parameter in indexer.Parameters)
                {
                    tempParameters[i++] = parameter;
                }

                // Add the implicit value parameter since this is a set accessor.
                tempParameters[i] = new Parameter(
                    indexer.ReturnType,
                    "value",
                    accessorReference,
                    ParameterModifiers.None,
                    null,
                    CodeLocation.Empty,
                    null,
                    indexer.ReturnType.Generated);

                this.parameters = tempParameters;
            }
        }
예제 #22
0
        /// <summary>
        /// Fills in the details of the get accessor.
        /// </summary>
        /// <param name="parent">The parent of the accessor.</param>
        private void FillGetAccessorDetails(CsElement parent)
        {
            Param.AssertNotNull(parent, "parent");

            Property property = parent as Property;
            if (property != null)
            {
                // Get accessors on properties have the return type of their parent property,
                // and have no input parameters.
                this.returnType = property.ReturnType;
            }
            else
            {
                // Get accessors on indexers have the return type of their parent indexer,
                // and have the input parameters of the parent indexer.
                Indexer indexer = (Indexer)parent;

                this.returnType = indexer.ReturnType;
                this.parameters = indexer.Parameters;
            }
        }
예제 #23
0
        /// <summary>
        /// Fills in the details of the accessor based on its type.
        /// </summary>
        /// <param name="parent">The parent of the accessor.</param>
        private void FillDetails(CsElement parent)
        {
            Param.AssertNotNull(parent, "parent");

            // Set the return type and parameters.
            if (this.accessorType == AccessorType.Get)
            {
                this.FillGetAccessorDetails(parent);
            }
            else if (this.accessorType == AccessorType.Set)
            {
                this.FillSetAccessorDetails(parent);
            }
            else
            {
                // Add and remove accessors have no return type but have an implied
                // parameter based on the type of the event handler.
                Event parentEvent = (Event)parent;
                var accessorReference = new Reference<ICodePart>(this);

                this.returnType = CreateVoidTypeToken(accessorReference);

                this.parameters = new Parameter[]
                {
                    new Parameter(
                        parentEvent.EventHandlerType,
                        "value",
                        accessorReference,
                        ParameterModifiers.None,
                        null,
                        CodeLocation.Empty,
                        null,
                        parentEvent.EventHandlerType.Generated)
                };
            }
        }
예제 #24
0
        /// <summary>
        /// Parses and returns the declarators for a field.
        /// </summary>
        /// <param name="fieldReference">A reference to the field.</param>
        /// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
        /// <param name="fieldType">The field type.</param>
        /// <returns>Returns the declarators.</returns>
        private IList<VariableDeclaratorExpression> ParseFieldDeclarators(Reference<ICodePart> fieldReference, bool unsafeCode, TypeToken fieldType)
        {
            Param.AssertNotNull(fieldReference, "fieldReference");
            Param.Ignore(unsafeCode);
            Param.AssertNotNull(fieldType, "fieldType");

            List<VariableDeclaratorExpression> declarators = new List<VariableDeclaratorExpression>();
            Symbol symbol = this.GetNextSymbol(fieldReference);

            while (symbol.SymbolType != SymbolType.Semicolon)
            {
                var expressionReference = new Reference<ICodePart>();

                // Get the identifier.
                CsToken identifier = this.GetElementNameToken(expressionReference, unsafeCode, true);
                Node<CsToken> identifierTokenNode = this.tokens.InsertLast(identifier);

                Expression initialization = null;

                // Check whether there is an equals sign.
                symbol = this.GetNextSymbol(expressionReference);
                if (symbol.SymbolType == SymbolType.Equals)
                {
                    this.tokens.Add(this.GetOperatorToken(OperatorType.Equals, expressionReference));

                    // Get the expression after the equals sign. If the expression starts with an
                    // opening curly bracket, then this is an initialization expression or an
                    // anonymous type initialization expression.
                    symbol = this.GetNextSymbol(expressionReference);
                    if (symbol.SymbolType == SymbolType.OpenCurlyBracket)
                    {
                        // Determine whether this is an array or an anonymous type.
                        if (fieldType.Text == "var" || (
                            fieldType.Text != "Array" && fieldType.Text != "System.Array" && !fieldType.Text.Contains("[")))
                        {
                            initialization = this.GetAnonymousTypeInitializerExpression(expressionReference, unsafeCode);
                        }
                        else
                        {
                            initialization = this.GetArrayInitializerExpression(unsafeCode);
                        }
                    }
                    else
                    {
                        initialization = this.GetNextExpression(ExpressionPrecedence.None, expressionReference, unsafeCode);
                    }

                    if (initialization == null)
                    {
                        throw this.CreateSyntaxException();
                    }
                }

                var variableDeclarationExpression = new VariableDeclaratorExpression(
                    new CsTokenList(this.tokens, identifierTokenNode, this.tokens.Last),
                    new LiteralExpression(this.tokens, identifierTokenNode),
                    initialization);

                expressionReference.Target = variableDeclarationExpression;
                declarators.Add(variableDeclarationExpression);

                // If the next symbol is a comma, continue.
                symbol = this.GetNextSymbol(fieldReference);
                if (symbol.SymbolType == SymbolType.Comma)
                {
                    this.tokens.Add(this.GetToken(CsTokenType.Comma, SymbolType.Comma, fieldReference));
                    symbol = this.GetNextSymbol(fieldReference);
                }
            }

            // Return the declarators as a read-only collection.
            return declarators.ToArray();
        }
예제 #25
0
        /// <summary>
        /// Checks for the presence of a return value tag on an element.
        /// </summary>
        /// <param name="element">The element to parse.</param>
        /// <param name="returnType">The return type.</param>
        /// <param name="formattedDocs">The formatted Xml document that comprises the header.</param>
        private void CheckHeaderReturnValue(CsElement element, TypeToken returnType, XmlDocument formattedDocs)
        {
            Param.AssertNotNull(element, "element");
            Param.Ignore(returnType);
            Param.AssertNotNull(formattedDocs, "formattedDocs");

            if (returnType != null)
            {
                XmlNode returnNode = formattedDocs.SelectSingleNode("root/returns");
                if (returnType.Text != "void")
                {
                    if (null == returnNode)
                    {
                        this.AddViolation(element, Rules.ElementReturnValueMustBeDocumented);
                    }
                    else if (returnNode.InnerText == null || returnNode.InnerText.Length == 0)
                    {
                        this.AddViolation(element, Rules.ElementReturnValueDocumentationMustHaveText);
                    }
                    else
                    {
                        this.CheckDocumentationValidity(element, element.LineNumber, returnNode, "return");
                    }
                }
                else
                {
                    if (null != returnNode)
                    {
                        this.AddViolation(element, Rules.VoidReturnValueMustNotBeDocumented);
                    }
                }
            }
        }
 internal DefaultValueExpression(CsTokenList tokens, LiteralExpression type)
     : base(ExpressionType.DefaultValue, tokens)
 {
     this.type = CodeParser.ExtractTypeTokenFromLiteralExpression(type);
     base.AddExpression(type);
 }
예제 #27
0
        /// <summary>
        /// Initializes a new instance of the Parameter class.
        /// </summary>
        /// <param name="type">The type of the parameter.</param>
        /// <param name="name">The name of the parameter.</param>
        /// <param name="parent">The parent of the parameter.</param>
        /// <param name="modifiers">Modifers applied to this parameter.</param>
        /// <param name="defaultArgument">The optional default argument for the parameter.</param>
        /// <param name="location">The location of the parameter in the code.</param>
        /// <param name="tokens">The tokens that form the parameter.</param>
        /// <param name="generated">Indicates whether the parameter is located within a block of generated code.</param>
        internal Parameter(
            TypeToken type, 
            string name, 
            Reference<ICodePart> parent,
            ParameterModifiers modifiers, 
            Expression defaultArgument, 
            CodeLocation location, 
            CsTokenList tokens, 
            bool generated)
        {
            Param.Ignore(type);
            Param.AssertValidString(name, "name");
            Param.AssertNotNull(parent, "parent");
            Param.Ignore(modifiers);
            Param.Ignore(defaultArgument);
            Param.AssertNotNull(location, "location");
            Param.Ignore(tokens);
            Param.Ignore(generated);

            this.type = type;
            this.name = name;
            this.parent = parent;
            this.modifiers = modifiers;
            this.defaultArgument = defaultArgument;
            this.location = location;
            this.tokens = tokens;
            this.generated = generated;
        }
예제 #28
0
 private LiteralExpression ConvertTypeExpression(Expression expression)
 {
     Microsoft.StyleCop.Node<CsToken> first = expression.Tokens.First;
     Microsoft.StyleCop.Node<CsToken> last = expression.Tokens.Last;
     List<CsToken> items = new List<CsToken>();
     foreach (CsToken token in expression.Tokens)
     {
         items.Add(token);
     }
     if ((first != null) && (expression.Tokens.First != null))
     {
         Microsoft.StyleCop.Node<CsToken> next = first.Next;
         if (!expression.Tokens.OutOfBounds(next))
         {
             this.tokens.RemoveRange(next, expression.Tokens.Last);
         }
     }
     MasterList<CsToken> childTokens = new MasterList<CsToken>(items);
     TypeToken newItem = new TypeToken(childTokens, CodeLocation.Join<CsToken>(first, last), first.Value.Generated);
     return new LiteralExpression(new CsTokenList(this.tokens, first, first), this.tokens.Replace(first, newItem));
 }
        /// <summary>
        /// Converts the given expression into a literal expression containing a type token.
        /// </summary>
        /// <param name="expression">The expression to convert.</param>
        /// <returns>Returns the converted expression.</returns>
        private LiteralExpression ConvertTypeExpression(Expression expression)
        {
            Param.AssertNotNull(expression, "expression");

            // Get the first and last token in the expression.
            Node<CsToken> firstTokenNode = expression.Tokens.First;
            Node<CsToken> lastTokenNode = expression.Tokens.Last;

            var typeTokenReference = new Reference<ICodePart>();
            var expressionReference = new Reference<ICodePart>();

            // Create a new token list containing these tokens.
            List<CsToken> tokenList = new List<CsToken>();
            foreach (CsToken token in expression.Tokens)
            {
                tokenList.Add(token);
                token.ParentRef = typeTokenReference;
            }

            // Remove the extra tokens from the master list.
            if (firstTokenNode != null && expression.Tokens.First != null)
            {
                Node<CsToken> temp = firstTokenNode.Next;
                if (!expression.Tokens.OutOfBounds(temp))
                {
                    this.tokens.RemoveRange(temp, expression.Tokens.Last);
                }
            }

            // Add the child tokens to a token list.
            MasterList<CsToken> childTokens = new MasterList<CsToken>(tokenList);

            // Create the new type token.
            TypeToken typeToken = new TypeToken(
                childTokens, CsToken.JoinLocations(firstTokenNode, lastTokenNode), expressionReference,  firstTokenNode.Value.Generated);
            typeTokenReference.Target = typeToken;

            // Insert the new token.
            Node<CsToken> typeTokenNode = this.tokens.Replace(firstTokenNode, typeToken);

            // Create the literal expression.
            var literalExpression = new LiteralExpression(
                new CsTokenList(this.tokens, firstTokenNode, firstTokenNode),
                typeTokenNode);

            expressionReference.Target = literalExpression;

            return literalExpression;
        }
예제 #30
0
        /// <summary>
        /// Gets a token representing a type identifier.
        /// </summary>
        /// <param name="typeTokenReference">A reference to the type token.</param>
        /// <param name="parentReference">The parent code unit.</param>
        /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
        /// <param name="includeArrayBrackets">Indicates whether to include array brackets in the type token.</param>
        /// <param name="isExpression">Indicates whether this type token comes at the end of an 'is' expression.</param>
        /// <param name="startIndex">The start position in the symbol list of the first symbol in the type token.</param>
        /// <param name="endIndex">Returns the index of the last symbol in the type token.</param>
        /// <returns>Returns the token.</returns>
        private TypeToken GetTypeTokenAux(
            Reference<ICodePart> typeTokenReference, 
            Reference<ICodePart> parentReference, 
            bool unsafeCode, 
            bool includeArrayBrackets, 
            bool isExpression, 
            int startIndex, 
            out int endIndex)
        {
            Param.AssertNotNull(typeTokenReference, "typeTokenReference");
            Param.AssertNotNull(parentReference, "parentReference");
            Param.Ignore(unsafeCode);
            Param.Ignore(includeArrayBrackets);
            Param.Ignore(isExpression);
            Param.AssertGreaterThanOrEqualToZero(startIndex, "startIndex");

            // Get the next symbol and make sure it is an unknown word.
            Symbol symbol = this.symbols.Peek(startIndex);
            Debug.Assert(symbol != null && symbol.SymbolType == SymbolType.Other, "Expected a text symbol");

            // Create a token list to store all the tokens forming the type.
            MasterList<CsToken> typeTokens = new MasterList<CsToken>();

            // Get the name of the type token plus any generic symbols and types.
            GenericType generic;

            this.GetTypeTokenBaseName(typeTokenReference, ref typeTokens, ref startIndex, out generic, unsafeCode);

            bool allowNullableType = true;

            // Add dereference symbols if they exist.
            if (unsafeCode)
            {
                if (this.GetTypeTokenDereferenceSymbols(typeTokenReference, typeTokens, ref startIndex))
                {
                    allowNullableType = false;
                }
            }

            // Now look for the nullable type symbol, if needed.
            if (allowNullableType)
            {
                this.GetTypeTokenNullableTypeSymbol(typeTokenReference, typeTokens, isExpression, ref startIndex);
            }

            // Get the array brackets if they exist.
            if (includeArrayBrackets)
            {
                this.GetTypeTokenArrayBrackets(typeTokenReference, typeTokens, ref startIndex);
            }

            if (typeTokens.Count == 0)
            {
                throw this.CreateSyntaxException();
            }

            // Set the end index.
            endIndex = startIndex - 1;

            // If the type is a generic type, determine whether to just return the generic type directly.
            if (generic != null && typeTokens.Count == 1)
            {
                // This type is only composed of the generic type and nothing else. Just return the generic type.
                generic.ParentRef = parentReference;
                return generic;
            }

            // The type is either not generic, or else it is composed of a more complex type which includes a generic
            // (for example, an array of a generic type). Return the more complex type.
            CodeLocation location = CsToken.JoinLocations(typeTokens.First, typeTokens.Last);
            var typeToken = new TypeToken(typeTokens, location, parentReference, this.symbols.Generated);
            typeTokenReference.Target = typeToken;

            return typeToken;
        }