/// <summary>
        /// Reads a new anonymous type allocation expression from the code.
        /// </summary>
        /// <param name="unsafeCode">
        /// Indicates whether the code being parsed resides in an unsafe code block.
        /// </param>
        /// <param name="firstTokenNode">
        /// The first token in the expression.
        /// </param>
        /// <param name="expressionReference">
        /// A reference to the expression being created.
        /// </param>
        /// <returns>
        /// Returns the expression.
        /// </returns>
        private NewExpression GetNewAnonymousTypeExpression(bool unsafeCode, Node<CsToken> firstTokenNode, Reference<ICodePart> expressionReference)
        {
            Param.Ignore(unsafeCode);
            Param.AssertNotNull(firstTokenNode, "firstTokenNode");
            Param.AssertNotNull(expressionReference, "expressionReference");

            // Get the anonymous type initializer expression.
            CollectionInitializerExpression initializer = this.GetAnonymousTypeInitializerExpression(expressionReference, unsafeCode);

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

            // Create and return the expression.
            NewExpression expression = new NewExpression(partialTokens, null, initializer);
            expressionReference.Target = expression;

            return expression;
        }
        /// <summary>
        /// Reads a new non-array type allocation expression from the code.
        /// </summary>
        /// <param name="unsafeCode">
        /// Indicates whether the code being parsed resides in an unsafe code block.
        /// </param>
        /// <param name="firstTokenNode">
        /// The first token in the expression.
        /// </param>
        /// <param name="type">
        /// The type of the array.
        /// </param>
        /// <param name="expressionReference">
        /// A reference to the expression being created.
        /// </param>
        /// <returns>
        /// Returns the expression.
        /// </returns>
        private NewExpression GetNewNonArrayTypeExpression(bool unsafeCode, Node<CsToken> firstTokenNode, Expression type, Reference<ICodePart> expressionReference)
        {
            Param.Ignore(unsafeCode);
            Param.AssertNotNull(firstTokenNode, "firstTokenNode");
            Param.AssertNotNull(type, "type");
            Param.AssertNotNull(expressionReference, "expressionReference");

            Expression typeCreationExpression = type;

            // If the next symbol is an opening parenthesis, then there is an argument
            // list which must be attached to the type creation expression.
            Symbol symbol = this.GetNextSymbol(expressionReference);

            if (symbol.SymbolType == SymbolType.OpenParenthesis)
            {
                typeCreationExpression = this.GetMethodInvocationExpression(type, ExpressionPrecedence.None, unsafeCode);
                if (typeCreationExpression == null || typeCreationExpression.Tokens.First == null)
                {
                    throw this.CreateSyntaxException();
                }
            }

            // If the next symbol is an opening curly bracket, then there is an object
            // or collection initializer attached which must also be parsed.
            symbol = this.GetNextSymbol(expressionReference);

            Expression initializer = null;
            if (symbol.SymbolType == SymbolType.OpenCurlyBracket)
            {
                initializer = this.GetObjectOrCollectionInitializerExpression(expressionReference, unsafeCode);

                if (initializer == null || initializer.Tokens.First == null)
                {
                    throw this.CreateSyntaxException();
                }
            }

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

            // Create and return the expression.
            NewExpression expression = new NewExpression(partialTokens, typeCreationExpression, initializer);
            expressionReference.Target = expression;

            return expression;
        }
        /// <summary>
        /// The save.
        /// </summary>
        /// <param name="newExpression">
        /// The new expression.
        /// </param>
        private void Save(NewExpression newExpression)
        {
            var methodInvocationExpression = newExpression.TypeCreationExpression as MethodInvocationExpression;
            if (methodInvocationExpression != null)
            {
                this.cppWriter.Write("ref new ");

                this.Save(methodInvocationExpression.Name.Text, this.cppWriter, SavingOptions.RemovePointer);
                this.cppWriter.Write("(");
                this.Save(methodInvocationExpression.Arguments);
                this.cppWriter.Write(")");

                @switch(newExpression.InitializerExpression);
            }
            else
            {
                throw new NotImplementedException();
            }
        }