public new void AddChildren()
 {
     base.AddChildren();
     Kind                   = Node.Kind();
     _argumentList          = ((ElementBindingExpressionSyntax)Node).ArgumentList;
     _argumentListIsChanged = false;
 }
 public new void AddChildren()
 {
     base.AddChildren();
     Kind                   = Node.Kind();
     _argumentList          = ((ImplicitElementAccessSyntax)Node).ArgumentList;
     _argumentListIsChanged = false;
 }
Example #3
0
        private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax argumentListSyntax)
        {
            var openBracketToken = argumentListSyntax.OpenBracketToken;

            if (openBracketToken.IsMissing ||
                argumentListSyntax.IsMissing ||
                !argumentListSyntax.Arguments.Any())
            {
                return;
            }

            var firstArgument = argumentListSyntax.Arguments[0];

            var firstArgumentLineSpan = firstArgument.GetLocation().GetLineSpan();

            if (!firstArgumentLineSpan.IsValid)
            {
                return;
            }

            var openBracketLineSpan = openBracketToken.GetLocation().GetLineSpan();

            if (!openBracketLineSpan.IsValid)
            {
                return;
            }

            if (openBracketLineSpan.EndLinePosition.Line != firstArgumentLineSpan.StartLinePosition.Line &&
                openBracketLineSpan.EndLinePosition.Line != (firstArgumentLineSpan.StartLinePosition.Line - 1))
            {
                context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstArgument.GetLocation()));
            }
        }
Example #4
0
 public override void VisitBracketedArgumentList(BracketedArgumentListSyntax argumentList)
 {
     foreach (ArgumentSyntax argument in argumentList.Arguments)
     {
         Visit(argument);
     }
 }
Example #5
0
        private static void AnalyzeBal(SyntaxNodeAnalysisContext context)
        {
            SyntaxNode node = context.Node;

            if (!node.IsKind(SyntaxKind.BracketedArgumentList))
            {
                return;
            }

            BracketedArgumentListSyntax bal = (BracketedArgumentListSyntax)node;
            ITypeSymbol type = null;

            //account["name"] = "test";
            if (bal.Parent.IsKind(SyntaxKind.ElementAccessExpression))
            {
                ElementAccessExpressionSyntax parent = (ElementAccessExpressionSyntax)bal.Parent;
                if (!parent.Expression.IsKind(SyntaxKind.IdentifierName))
                {
                    return;
                }

                IdentifierNameSyntax identifier = (IdentifierNameSyntax)parent.Expression;
                if (identifier != null)
                {
                    type = context.SemanticModel.GetTypeInfo(identifier).Type;
                }
            }

            //Entity account = new Entity("account") { ["name"] = "test" };
            if (bal.Parent.IsKind(SyntaxKind.ImplicitElementAccess))
            {
                ImplicitElementAccessSyntax    parent     = (ImplicitElementAccessSyntax)bal.Parent;
                ObjectCreationExpressionSyntax identifier = parent.Ancestors().OfType <ObjectCreationExpressionSyntax>().First();
                if (identifier != null)
                {
                    type = context.SemanticModel.GetTypeInfo(identifier).Type;
                }
            }

            if (type == null)
            {
                return;
            }

            //If type is not Microsoft.Xrm.Sdk.Entity - exit
            if (type.ToString() != "Microsoft.Xrm.Sdk.Entity")
            {
                return;
            }

            //If arguement does not contain an upper case letter - exit
            if (!bal.Arguments.ToString().ToCharArray().Any(char.IsUpper))
            {
                return;
            }

            var diagnostic = Diagnostic.Create(Rule, node.GetLocation(), bal.Arguments[0].Expression.GetFirstToken().ValueText);

            context.ReportDiagnostic(diagnostic);
        }
Example #6
0
        public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            foreach (ArgumentSyntax argument in node.Arguments)
            {
                argument.Accept(this);
            }

            base.VisitBracketedArgumentList(node);
        }
Example #7
0
        public override UstNode VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            Expression[] args = node.Arguments.Select(arg => (Expression)VisitAndReturnNullIfError(arg))
                                .ToArray();

            var result = new ArgsNode(args, node.GetTextSpan(), FileNode);

            return(result);
        }
        private static bool CanExpand(
            InitializerExpressionSyntax initializer,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            var objectCreationExpression = (ObjectCreationExpressionSyntax)initializer.Parent;

            if (objectCreationExpression.Type != null)
            {
                ExpressionSyntax expression = initializer.Expressions[0];

                if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
                {
                    var assignment = (AssignmentExpressionSyntax)expression;

                    ExpressionSyntax left = assignment.Left;

                    if (left.IsKind(SyntaxKind.ImplicitElementAccess))
                    {
                        var implicitElementAccess = (ImplicitElementAccessSyntax)left;

                        BracketedArgumentListSyntax argumentList = implicitElementAccess.ArgumentList;

                        if (argumentList?.Arguments.Any() == true)
                        {
                            return(HasPublicWritableIndexer(
                                       argumentList.Arguments[0].Expression,
                                       objectCreationExpression,
                                       semanticModel,
                                       cancellationToken));
                        }
                    }
                    else
                    {
                        return(true);
                    }
                }
                else if (expression.IsKind(SyntaxKind.ComplexElementInitializerExpression))
                {
                    var initializerExpression = (InitializerExpressionSyntax)expression;

                    SeparatedSyntaxList <ExpressionSyntax> expressions = initializerExpression.Expressions;

                    if (expressions.Any())
                    {
                        return(HasPublicWritableIndexer(expressions[0], objectCreationExpression, semanticModel, cancellationToken));
                    }
                }
                else
                {
                    return(HasPublicAddMethod(expression, objectCreationExpression, semanticModel, cancellationToken));
                }
            }

            return(false);
        }
 public override void AddChildren()
 {
     Kind                   = Node.Kind();
     _identifier            = ((VariableDeclaratorSyntax)Node).Identifier;
     _identifierIsChanged   = false;
     _argumentList          = ((VariableDeclaratorSyntax)Node).ArgumentList;
     _argumentListIsChanged = false;
     _initializer           = ((VariableDeclaratorSyntax)Node).Initializer;
     _initializerIsChanged  = false;
 }
Example #10
0
        public override Evaluation VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            EvaluationList list = new EvaluationList();

            foreach (ArgumentSyntax argument in node.Arguments)
            {
                list.Add(argument.Accept <Evaluation>(this));
            }

            return(list);
        }
Example #11
0
        private VariableState VisitElementAccess(ElementAccessExpressionSyntax elementAccess,
                                                 BracketedArgumentListSyntax argumentList,
                                                 ExecutionState state)
        {
            foreach (var argument in argumentList.Arguments)
            {
                VisitExpression(argument.Expression, state);
            }

            return(new VariableState(elementAccess, VariableTaint.Unknown));
        }
Example #12
0
        public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            var arguments = new List <Argument>();

            foreach (var argument in node.Arguments)
            {
                arguments.Add(VisitSyntaxNode(argument) as Argument);
            }

            _currentNode = new BracketedArgumentList(new ArgumentList(arguments));
        }
 public static Doc Print(BracketedArgumentListSyntax node)
 {
     return(Doc.Group(
                Token.Print(node.OpenBracketToken),
                Doc.Indent(
                    Doc.SoftLine,
                    SeparatedSyntaxList.Print(node.Arguments, Node.Print, Doc.Line)
                    ),
                Doc.SoftLine,
                Token.Print(node.CloseBracketToken)
                ));
 }
Example #14
0
        public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            var oper = m_Model.GetOperation(node);

            if (oper.Kind == OperationKind.IndexedPropertyReferenceExpression)
            {
                OutputArgumentList(node.Arguments, ", ", oper);
            }
            else
            {
                OutputArgumentList(node.Arguments, "][", oper);
            }
        }
        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ReplaceElementAccessWithInvocation))
            {
                return;
            }

            SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);

            if (!TryFindFirstAncestorOrSelf(root, context.Span, out ElementAccessExpressionSyntax elementAccess))
            {
                return;
            }

            foreach (Diagnostic diagnostic in context.Diagnostics)
            {
                switch (diagnostic.Id)
                {
                case CompilerDiagnosticIdentifiers.CannotApplyIndexingToExpression:
                {
                    SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

                    BracketedArgumentListSyntax argumentList = elementAccess.ArgumentList;

                    SyntaxToken openBracket  = argumentList.OpenBracketToken;
                    SyntaxToken closeBracket = argumentList.CloseBracketToken;

                    InvocationExpressionSyntax invocationExpression = InvocationExpression(
                        elementAccess.Expression,
                        ArgumentList(
                            Token(openBracket.LeadingTrivia, SyntaxKind.OpenParenToken, openBracket.TrailingTrivia),
                            argumentList.Arguments,
                            Token(closeBracket.LeadingTrivia, SyntaxKind.CloseParenToken, closeBracket.TrailingTrivia)));

                    if (semanticModel.GetSpeculativeMethodSymbol(elementAccess.SpanStart, invocationExpression) == null)
                    {
                        break;
                    }

                    CodeAction codeAction = CodeAction.Create(
                        "Replace [] with ()",
                        cancellationToken => context.Document.ReplaceNodeAsync(elementAccess, invocationExpression, cancellationToken),
                        GetEquivalenceKey(diagnostic));

                    context.RegisterCodeFix(codeAction, diagnostic);
                    break;
                }
                }
            }
        }
Example #16
0
 public static Task <Document> FixListAsync(
     Document document,
     BracketedArgumentListSyntax bracketedArgumentList,
     ListFixMode fixMode = ListFixMode.Fix,
     CancellationToken cancellationToken = default)
 {
     return(FixListAsync(
                document,
                bracketedArgumentList,
                bracketedArgumentList.OpenBracketToken,
                bracketedArgumentList.Arguments,
                fixMode,
                cancellationToken));
 }
        private async Task <Document> MakeLowercaseAsync(Document document, SyntaxNode node, CancellationToken cancellationToken)
        {
            var root = await document.GetSyntaxRootAsync(cancellationToken);

            BracketedArgumentListSyntax bal = (BracketedArgumentListSyntax)node;
            var newFieldName = bal.Arguments.FirstOrDefault().ToString().ToLowerInvariant();

            var newNode = SyntaxFactory.BracketedArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>().Add(
                                                                  SyntaxFactory.Argument(null, SyntaxFactory.Token(SyntaxKind.None),
                                                                                         SyntaxFactory.IdentifierName(newFieldName))));

            var newRoot = root.ReplaceNode(node, newNode);

            return(document.WithSyntaxRoot(newRoot));
        }
Example #18
0
        public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            if (!PreVisit(node))
            {
                return;
            }

            foreach (ArgumentSyntax argument in node.Arguments)
            {
                argument.Accept(this);
            }

            base.VisitBracketedArgumentList(node);

            PostVisit(node);
        }
            private Int32 ExtractParameterFromCondition(ExpressionSyntax condition)
            {
                ElementAccessExpressionSyntax elementAccessExpression = condition as ElementAccessExpressionSyntax;

                if (elementAccessExpression == null)
                {
                    // unexpected case
                    throw new NotSupportedException();
                }
                BracketedArgumentListSyntax args = elementAccessExpression.ArgumentList;

                if (args.Arguments.Count != 1)
                {
                    // unexpected case
                    throw new NotSupportedException();
                }
                return(Int32.Parse(args.Arguments[0].Expression.GetText().ToString()));
            }
Example #20
0
 private Doc PrintBracketedArgumentListSyntax(
     BracketedArgumentListSyntax node)
 {
     return(Group(
                this.PrintSyntaxToken(node.OpenBracketToken),
                Indent(
                    Concat(
                        SoftLine,
                        this.PrintSeparatedSyntaxList(
                            node.Arguments,
                            this.Print,
                            Line
                            )
                        )
                    ),
                SoftLine,
                this.PrintSyntaxToken(node.CloseBracketToken)
                ));
 }
        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            Diagnostic diagnostic = context.Diagnostics[0];

            SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);

            if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.ReplaceElementAccessWithInvocation, context.Document, root.SyntaxTree))
            {
                return;
            }

            if (!TryFindFirstAncestorOrSelf(root, context.Span, out ElementAccessExpressionSyntax elementAccess))
            {
                return;
            }

            SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

            BracketedArgumentListSyntax argumentList = elementAccess.ArgumentList;

            SyntaxToken openBracket  = argumentList.OpenBracketToken;
            SyntaxToken closeBracket = argumentList.CloseBracketToken;

            InvocationExpressionSyntax invocationExpression = InvocationExpression(
                elementAccess.Expression,
                ArgumentList(
                    Token(openBracket.LeadingTrivia, SyntaxKind.OpenParenToken, openBracket.TrailingTrivia),
                    argumentList.Arguments,
                    Token(closeBracket.LeadingTrivia, SyntaxKind.CloseParenToken, closeBracket.TrailingTrivia)));

            if (semanticModel.GetSpeculativeMethodSymbol(elementAccess.SpanStart, invocationExpression) == null)
            {
                return;
            }

            CodeAction codeAction = CodeAction.Create(
                "Replace [] with ()",
                ct => context.Document.ReplaceNodeAsync(elementAccess, invocationExpression, ct),
                GetEquivalenceKey(diagnostic));

            context.RegisterCodeFix(codeAction, diagnostic);
        }
        /// <summary>
        /// Generates an element access expression
        /// </summary>
        /// <param name="node">The expression</param>
        public override void Generate(ElementAccessExpressionSyntax node)
        {
            m_context.Writer.ShouldOutputPost = true;

            IEnumerable <SyntaxNode> nodes = node.ChildNodes();

            foreach (SyntaxNode child in nodes)
            {
                SyntaxKind kind = child.Kind();

                if (kind == SyntaxKind.IdentifierName)
                {
                    ISymbol symbol = m_context.Model.GetSymbolInfo(child).Symbol;
                    if (symbol.Kind == SymbolKind.Field && !symbol.IsStatic)
                    {
                        m_context.Writer.Append("obj->");
                    }

                    m_context.Writer.Append(m_context.TypeConvert.ConvertVariableName(child));
                }
                else if (kind == SyntaxKind.BracketedArgumentList)
                {
                    BracketedArgumentListSyntax args     = child as BracketedArgumentListSyntax;
                    IEnumerable <SyntaxNode>    children = args.ChildNodes();

                    m_context.Writer.Append("[");

                    foreach (ArgumentSyntax childNode in children)
                    {
                        m_context.Generators.Expression.Generate(childNode.Expression);
                    }

                    m_context.Writer.Append("]");
                }
                else
                {
                    m_context.Generators.Expression.Generate(child);
                }
            }

            m_context.Writer.ShouldOutputPost = false;
        }
Example #23
0
        private VariableState VisitElementAccess(ElementAccessExpressionSyntax elementAccess,
                                                 BracketedArgumentListSyntax argumentList,
                                                 ExecutionState state)
        {
            var finalState = new VariableState(elementAccess, VariableTaint.Unset);

            foreach (var argument in argumentList.Arguments)
            {
                finalState.MergeTaint(VisitExpression(argument.Expression, state).Taint);
            }

            finalState.MergeTaint(VisitExpression(elementAccess.Expression, state).Taint);

            var taintSourceState = CheckIfTaintSource(elementAccess, state);

            if (taintSourceState != null)
            {
                finalState.MergeTaint(taintSourceState.Taint);
            }

            return(finalState);
        }
Example #24
0
 private bool IsBracketedArgumentListMissingBrackets(BracketedArgumentListSyntax node)
 {
     return node != null && node.OpenBracketToken.IsMissing && node.CloseBracketToken.IsMissing;
 }
 private static void HandleBracketedArgumentListSyntax(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax bracketedArgumentList)
 {
     SeparatedSyntaxList<ArgumentSyntax> arguments = bracketedArgumentList.Arguments;
     if (arguments.Count > 2)
     {
         Analyze(context, arguments);
     }
 }
Example #26
0
 public static void Write(this BracketedArgumentListSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
 {
     textWriter.Write("[");
     syntax.Arguments.Single().Write(textWriter, context);
     textWriter.Write("]");
 }
Example #27
0
 private bool IsBracketedArgumentListMissingBrackets(BracketedArgumentListSyntax node)
 {
     return(node != null && node.OpenBracketToken.IsMissing && node.CloseBracketToken.IsMissing);
 }
        private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax argumentListSyntax)
        {
            var openBracketToken = argumentListSyntax.OpenBracketToken;
            if (openBracketToken.IsMissing ||
                argumentListSyntax.IsMissing ||
                !argumentListSyntax.Arguments.Any())
            {
                return;
            }

            var firstArgument = argumentListSyntax.Arguments[0];
            if (firstArgument.GetLeadingTrivia().Any(SyntaxKind.PragmaWarningDirectiveTrivia))
            {
                return;
            }

            var firstArgumentLineSpan = firstArgument.GetLineSpan();
            if (!firstArgumentLineSpan.IsValid)
            {
                return;
            }

            var openBracketLineSpan = openBracketToken.GetLineSpan();
            if (!openBracketLineSpan.IsValid)
            {
                return;
            }

            if (openBracketLineSpan.EndLinePosition.Line != firstArgumentLineSpan.StartLinePosition.Line &&
                openBracketLineSpan.EndLinePosition.Line != (firstArgumentLineSpan.StartLinePosition.Line - 1))
            {
                context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstArgument.GetLocation()));
            }
        }
 public override string VisitBracketedArgumentList(BracketedArgumentListSyntax node)
 {
     return(node.OpenBracketToken.ToFullString()
            + string.Join(", ", node.Arguments.Select(argSyntax => Visit(argSyntax)))
            + node.CloseBracketToken.ToFullString());
 }
        private static void HandleBracketedArgumentListSyntax(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax bracketedArgumentList)
        {
            SeparatedSyntaxList <ArgumentSyntax> arguments = bracketedArgumentList.Arguments;

            if (arguments.Count > 2)
            {
                Analyze(context, arguments);
            }
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 public override sealed void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
 {
     this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
     base.VisitBracketedArgumentList(node);
 }
Example #32
0
 protected ElementAccess(ExpressionNodeInfo info, ExpressionSyntax qualifier, BracketedArgumentListSyntax argumentList)
     : base(info.SetKind(GetKind(info.Context, qualifier)))
 {
     this.qualifier    = qualifier;
     this.argumentList = argumentList;
 }
Example #33
0
        public List<FlatOperand> ResolveArguments(BracketedArgumentListSyntax args, List<FlatStatement> instructions)
        {
            List<FlatOperand> list = new List<FlatOperand>();

            if (args == null || args.Arguments.Count == 0)
                return list;

            foreach (ArgumentSyntax arg in args.Arguments)
            {
                list.Add(ResolveArgument(arg, null, instructions));
            }

            return list;
        }
            private IEnumerable<ITypeSymbol> InferTypeInBracketedArgumentList(BracketedArgumentListSyntax bracketedArgumentList, SyntaxToken previousToken)
            {
                // Has to follow the [ or a ,
                if (previousToken != bracketedArgumentList.OpenBracketToken && previousToken.CSharpKind() != SyntaxKind.CommaToken)
                {
                    return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
                }

                var elementAccess = bracketedArgumentList.Parent as ElementAccessExpressionSyntax;
                if (elementAccess != null)
                {
                    var index = GetArgumentListIndex(bracketedArgumentList, previousToken);
                    return InferTypeInElementAccessExpression(
                        elementAccess, index);
                }

                return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
            }
        private static void HandleBracketedArgumentListSyntax(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax bracketedArgumentList)
        {
            SeparatedSyntaxList<ArgumentSyntax> parameters = bracketedArgumentList.Arguments;

            if (parameters.Count > 1)
            {
                Analyze(context, bracketedArgumentList.OpenBracketToken, parameters[0], parameters[1]);
            }
        }
Example #36
0
        private static void HandleBracketedArgumentListSyntax(SyntaxNodeAnalysisContext context, BracketedArgumentListSyntax bracketedArgumentList)
        {
            SeparatedSyntaxList <ArgumentSyntax> parameters = bracketedArgumentList.Arguments;

            if (parameters.Count > 1)
            {
                Analyze(context, bracketedArgumentList.OpenBracketToken, parameters[0], parameters[1]);
            }
        }
Example #37
0
        public void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
        {
            if (node == null)
                throw new ArgumentNullException("node");

            node.Validate();

            if (_writer.Configuration.Spaces.BeforeParentheses.ArrayAccessBrackets)
                _writer.WriteSpace();

            _writer.WriteSyntax(Syntax.OpenBracket);

            if (_writer.Configuration.Spaces.WithinParentheses.ArrayAccessBrackets)
                _writer.WriteSpace();

            bool hadOne = false;

            foreach (var parameter in node.Arguments)
            {
                if (hadOne)
                    _writer.WriteListSeparator();
                else
                    hadOne = true;

                parameter.Accept(this);
            }

            if (
                _writer.Configuration.Spaces.WithinParentheses.ArrayAccessBrackets &&
                node.Arguments.Count > 0
            )
                _writer.WriteSpace();

            _writer.WriteSyntax(Syntax.CloseBracket);
        }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 public override sealed void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
 {
     this.OnNodeVisited(node);
     if (!this.traverseRootOnly) base.VisitBracketedArgumentList(node);
 }
Example #39
0
        internal void Init(IMethodSymbol sym, BracketedArgumentListSyntax argList, SemanticModel model)
        {
            Init(sym);

            if (null != argList)
            {
                var moper = model.GetOperation(argList) as IInvocationExpression;
                var args  = argList.Arguments;

                IConversionExpression lastConv = null;
                int ct = args.Count;
                for (int i = 0; i < ct; ++i)
                {
                    var arg = args[i];
                    TryAddExternEnum(IsEnumClass, arg.Expression, model);
                    if (i < sym.Parameters.Length)
                    {
                        var param = sym.Parameters[i];
                        if (null != moper)
                        {
                            var iarg = moper.GetArgumentMatchingParameter(param);
                            if (null != iarg)
                            {
                                lastConv = iarg.Value as IConversionExpression;
                            }
                        }
                        if (!param.IsParams && param.Type.TypeKind == TypeKind.Array)
                        {
                            RecordRefArray(arg.Expression);
                        }
                        if (param.RefKind == RefKind.Ref)
                        {
                            Args.Add(arg.Expression);
                            ReturnArgs.Add(arg.Expression);
                        }
                        else if (param.RefKind == RefKind.Out)
                        {
                            //方法的out参数,为与脚本引擎的机制一致,在调用时传入__cs2dsl_out,这里用null标记一下,在实际输出参数时再变为__cs2dsl_out
                            Args.Add(null);
                            ReturnArgs.Add(arg.Expression);
                        }
                        else if (param.IsParams)
                        {
                            var argOper = model.GetOperation(arg.Expression);
                            if (null != argOper && null != argOper.Type && argOper.Type.TypeKind == TypeKind.Array && i == ct - 1)
                            {
                                ArrayToParams = true;
                            }
                            Args.Add(arg.Expression);
                        }
                        else
                        {
                            Args.Add(arg.Expression);
                        }
                    }
                    else
                    {
                        Args.Add(arg.Expression);
                    }
                    ArgConversions.Add(lastConv);
                }
                for (int i = ct; i < sym.Parameters.Length; ++i)
                {
                    var param = sym.Parameters[i];
                    if (param.HasExplicitDefaultValue)
                    {
                        var  decl    = param.DeclaringSyntaxReferences;
                        bool handled = false;
                        if (decl.Length >= 1)
                        {
                            var node = param.DeclaringSyntaxReferences[0].GetSyntax() as ParameterSyntax;
                            if (null != node)
                            {
                                var exp      = node.Default.Value;
                                var tree     = node.SyntaxTree;
                                var newModel = SymbolTable.Instance.Compilation.GetSemanticModel(tree, true);
                                if (null != newModel)
                                {
                                    var oper = newModel.GetOperation(exp);
                                    //var dsym = newModel.GetSymbolInfo(exp).Symbol;
                                    DefaultValueArgs.Add(new ArgDefaultValueInfo {
                                        Value = param.ExplicitDefaultValue, OperOrSym = oper
                                    });
                                    handled = true;
                                }
                            }
                        }
                        if (!handled)
                        {
                            DefaultValueArgs.Add(new ArgDefaultValueInfo {
                                Value = param.ExplicitDefaultValue, OperOrSym = null
                            });
                        }
                    }
                }
            }
        }
 public BracketedArgumentListTranslation(BracketedArgumentListSyntax syntax,  SyntaxTranslation parent) : base(syntax, parent)
 {
     
 }