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; }
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())); } }
public override void VisitBracketedArgumentList(BracketedArgumentListSyntax argumentList) { foreach (ArgumentSyntax argument in argumentList.Arguments) { Visit(argument); } }
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); }
public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node) { foreach (ArgumentSyntax argument in node.Arguments) { argument.Accept(this); } base.VisitBracketedArgumentList(node); }
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; }
public override Evaluation VisitBracketedArgumentList(BracketedArgumentListSyntax node) { EvaluationList list = new EvaluationList(); foreach (ArgumentSyntax argument in node.Arguments) { list.Add(argument.Accept <Evaluation>(this)); } return(list); }
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)); }
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) )); }
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; } } } }
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)); }
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())); }
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; }
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); }
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); } }
public static void Write(this BracketedArgumentListSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context) { textWriter.Write("["); syntax.Arguments.Single().Write(textWriter, context); textWriter.Write("]"); }
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); }
protected ElementAccess(ExpressionNodeInfo info, ExpressionSyntax qualifier, BracketedArgumentListSyntax argumentList) : base(info.SetKind(GetKind(info.Context, qualifier))) { this.qualifier = qualifier; this.argumentList = argumentList; }
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]); } }
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]); } }
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); }
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) { }