private IEnumerable<SignatureHelpItem> GetDelegateTypeConstructors( ObjectCreationExpressionSyntax objectCreationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService, INamedTypeSymbol delegateType, INamedTypeSymbol containingType, CancellationToken cancellationToken) { var invokeMethod = delegateType.DelegateInvokeMethod; if (invokeMethod == null) { return null; } var position = objectCreationExpression.SpanStart; var item = CreateItem( invokeMethod, semanticModel, position, symbolDisplayService, anonymousTypeDisplayService, isVariadic: false, documentationFactory: null, prefixParts: GetDelegateTypePreambleParts(invokeMethod, semanticModel, position), separatorParts: GetSeparatorParts(), suffixParts: GetDelegateTypePostambleParts(invokeMethod), parameters: GetDelegateTypeParameters(invokeMethod, semanticModel, position, cancellationToken)); return SpecializedCollections.SingletonEnumerable(item); }
public static string ObjectCreationExpression(ObjectCreationExpressionSyntax expression) { //Name all the arguments, since Swift usually requires named arguments when you create new objects. //Thanks! http://stackoverflow.com/questions/24174602/get-constructor-declaration-from-objectcreationexpressionsyntax-with-roslyn/24191494#24191494 var symbol = Model.GetSymbolInfo(expression).Symbol as IMethodSymbol; var namedArgumentsList = new SeparatedSyntaxList<ArgumentSyntax>(); for (var i = 0; i < expression.ArgumentList.Arguments.Count; i++) { var oldArgumentSyntax = expression.ArgumentList.Arguments[i]; var parameterName = symbol.Parameters[i].Name; var nameColonSyntax = SyntaxFactory .NameColon(SyntaxFactory.IdentifierName(parameterName)) .WithTrailingTrivia(SyntaxFactory.Whitespace(" ")); var namedArgumentSyntax = SyntaxFactory.Argument(nameColonSyntax, oldArgumentSyntax.RefOrOutKeyword, oldArgumentSyntax.Expression); namedArgumentsList = namedArgumentsList.Add(namedArgumentSyntax); } //NOTE: this takes out expression.parent and everything, and probably screws with SyntaxModel stuff to return SyntaxNode(expression.Type) + SyntaxNode(SyntaxFactory.ArgumentList(namedArgumentsList)); }
private static async Task<Document> ChangeToImmutableArrayCreateRange( ObjectCreationExpressionSyntax objectCreation, InitializerExpressionSyntax initializer, INamedTypeSymbol immutableArrayType, ITypeSymbol elementType, Document document, CancellationToken cancellationToken) { var generator = SyntaxGenerator.GetGenerator(document); var arrayElementType = (TypeSyntax)generator.TypeExpression(elementType); var arrayType = SyntaxFactory.ArrayType(arrayElementType, SyntaxFactory.SingletonList( SyntaxFactory.ArrayRankSpecifier( SyntaxFactory.SingletonSeparatedList( (ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression())))); var arrayCreationExpression = SyntaxFactory.ArrayCreationExpression( type: arrayType, initializer: SyntaxFactory.InitializerExpression( kind: SyntaxKind.ArrayInitializerExpression, expressions: initializer.Expressions)) .WithAdditionalAnnotations(Formatter.Annotation); var type = generator.TypeExpression(immutableArrayType); var memberAccess = generator.MemberAccessExpression(type, "CreateRange"); var invocation = generator.InvocationExpression(memberAccess, arrayCreationExpression); var oldRoot = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = oldRoot.ReplaceNode(objectCreation, invocation); return document.WithSyntaxRoot(newRoot); }
internal static bool CheckExceptionType(SemanticModel model, ObjectCreationExpressionSyntax objectCreateExpression, out ExpressionSyntax paramNode) { paramNode = null; var type = model.GetTypeInfo(objectCreateExpression).Type; if (type == null) return false; if (type.Name == typeof(ArgumentException).Name) { if (objectCreateExpression.ArgumentList.Arguments.Count >= 2) { paramNode = objectCreateExpression.ArgumentList.Arguments[1].Expression; } return paramNode != null; } if (type.Name == typeof(ArgumentNullException).Name || type.Name == typeof(ArgumentOutOfRangeException).Name || type.Name == "DuplicateWaitObjectException") { if (objectCreateExpression.ArgumentList.Arguments.Count >= 1) { paramNode = objectCreateExpression.ArgumentList.Arguments[0].Expression; } return paramNode != null; } return false; }
public static SyntaxNode CreateUsing(SyntaxNode root, ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { SyntaxNode newRoot; if (objectCreation.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression)) { var assignmentExpression = (AssignmentExpressionSyntax)objectCreation.Parent; var statement = assignmentExpression.Parent as ExpressionStatementSyntax; var identitySymbol = (ILocalSymbol)semanticModel.GetSymbolInfo(assignmentExpression.Left).Symbol; newRoot = UsedOutsideParentBlock(semanticModel, statement, identitySymbol) ? CreateRootAddingDisposeToEndOfMethod(root, statement, identitySymbol) : CreateRootWithUsing(root, statement, u => u.WithExpression(assignmentExpression)); } else if (objectCreation.Parent.IsKind(SyntaxKind.EqualsValueClause) && objectCreation.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator)) { var variableDeclarator = (VariableDeclaratorSyntax)objectCreation.Parent.Parent; var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent; var statement = (LocalDeclarationStatementSyntax)variableDeclaration.Parent; newRoot = CreateRootWithUsing(root, statement, u => u.WithDeclaration(variableDeclaration)); } else { newRoot = CreateRootWithUsing(root, (ExpressionStatementSyntax)objectCreation.Parent, u => u.WithExpression(objectCreation)); } return newRoot; }
public static bool GetClassificationForCommandCreation(ISemanticModel model, ObjectCreationExpressionSyntax syntax, CancellationToken cancellationToken = new CancellationToken()) { if (syntax == null) return false; var cmdType = model.GetSemanticInfo(syntax, cancellationToken); //var cmdType = model.GetSemanticInfo(syntax, cancellationToken); return cmdType.Type.AllInterfaces.AsList().Select(x => x.Name).Any(x => x == "ICommand"); }
private bool TryGetObjectCreationExpression(SyntaxNode root, int position, ISyntaxFactsService syntaxFacts, SignatureHelpTriggerReason triggerReason, CancellationToken cancellationToken, out ObjectCreationExpressionSyntax expression) { if (!CommonSignatureHelpUtilities.TryGetSyntax(root, position, syntaxFacts, triggerReason, IsTriggerToken, IsArgumentListToken, cancellationToken, out expression)) { return false; } return expression.ArgumentList != null; }
public static SyntaxNode CreateUsing(SyntaxNode root, ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { SyntaxNode newRoot; if (objectCreation.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression)) { var assignmentExpression = (AssignmentExpressionSyntax)objectCreation.Parent; var statement = assignmentExpression.Parent as ExpressionStatementSyntax; var identitySymbol = (ILocalSymbol)semanticModel.GetSymbolInfo(assignmentExpression.Left).Symbol; newRoot = UsedOutsideParentBlock(semanticModel, statement, identitySymbol) ? CreateRootAddingDisposeToEndOfMethod(root, statement, identitySymbol) : CreateRootWithUsing(root, statement, u => u.WithExpression(assignmentExpression)); } else if (objectCreation.Parent.IsKind(SyntaxKind.EqualsValueClause) && objectCreation.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator)) { var variableDeclarator = (VariableDeclaratorSyntax)objectCreation.Parent.Parent; var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent; var statement = (LocalDeclarationStatementSyntax)variableDeclaration.Parent; newRoot = CreateRootWithUsing(root, statement, u => u.WithDeclaration(variableDeclaration.WithoutLeadingTrivia())); } else if (objectCreation.Parent.IsKind(SyntaxKind.Argument)) { var identifierName = GetIdentifierName(objectCreation, semanticModel); var variableDeclaration = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(@"var")) .WithVariables(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(identifierName)) .WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), objectCreation)))); var arg = objectCreation.Parent as ArgumentSyntax; var args = objectCreation.Parent.Parent as ArgumentListSyntax; var newArgs = args.ReplaceNode(arg, arg.WithExpression(SyntaxFactory.IdentifierName(identifierName))); StatementSyntax statement = objectCreation.FirstAncestorOfType<ExpressionStatementSyntax>(); if (statement != null) { var exprStatement = statement.ReplaceNode(args, newArgs); var newUsingStatment = CreateUsingStatement(exprStatement, SyntaxFactory.Block(exprStatement)) .WithDeclaration(variableDeclaration); return root.ReplaceNode(statement, newUsingStatment); } statement = (StatementSyntax)objectCreation.Ancestors().First(node => node is StatementSyntax); var newStatement = statement.ReplaceNode(args, newArgs); var statementsForUsing = new[] { newStatement }.Concat(GetChildStatementsAfter(statement)); var usingBlock = SyntaxFactory.Block(statementsForUsing); var usingStatement = CreateUsingStatement(newStatement, usingBlock) .WithDeclaration(variableDeclaration); var statementsToReplace = new List<StatementSyntax> { statement }; statementsToReplace.AddRange(statementsForUsing.Skip(1)); newRoot = root.ReplaceNodes(statementsToReplace, (node, _) => node.Equals(statement) ? usingStatement : null); } else { newRoot = CreateRootWithUsing(root, (ExpressionStatementSyntax)objectCreation.Parent, u => u.WithExpression(objectCreation)); } return newRoot; }
public BoundObjectCreationExpression( IType type, IConstructor boundConstructor, List<BoundExpression> boundParameter, ObjectCreationExpressionSyntax expressionSyntax) : base(expressionSyntax, type) { BoundConstructor = boundConstructor; BoundParameter = boundParameter; }
private static async Task<Document> ChangeToImmutableArrayEmpty(ObjectCreationExpressionSyntax objectCreation, Document document, CancellationToken cancellationToken) { var generator = SyntaxGenerator.GetGenerator(document); var memberAccess = generator.MemberAccessExpression(objectCreation.Type, "Empty"); var oldRoot = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = oldRoot.ReplaceNode(objectCreation, memberAccess); return document.WithSyntaxRoot(newRoot); }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newAssignmentExpressions = new List<ExpressionStatementSyntax>(); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; initializationExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right)); } var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia("\n")), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); if (newObjectCreationExpression.ArgumentList?.Arguments.Count == 0) { newObjectCreationExpression = newObjectCreationExpression.WithArgumentList(null); } var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol; if (symbol != null) { IsAsyncLibraryConstruct(symbol.OriginalDefinition); } base.VisitObjectCreationExpression(node); }
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { var symbol = SemanticModel.GetSymbolInfo(node).Symbol; if (symbol != null) { Enums.ThreadingNamespaceDetected type = CheckThreadingUsage(symbol); Result.StoreDetectedThreadingNamespaceUsage(type); Result.WriteDetectedThreadingNamespaceUsage(type, Document.FilePath, symbol, node); } base.VisitObjectCreationExpression(node); }
private bool IsDefaultCtorOnStruct(ObjectCreationExpressionSyntax objectCreation, ITypeSymbol symbol, SemanticModel semanticModel) { if (symbol.IsValueType) { var ctor = semanticModel.GetSymbolInfo(objectCreation).Symbol as IMethodSymbol; if (ctor != null) { return ctor.Parameters.Length == 0; } } return false; }
internal static List<string> GetValidParameterNames(ObjectCreationExpressionSyntax objectCreateExpression) { var names = new List<string>(); var node = objectCreateExpression.Parent; while (node != null && !(node is TypeBlockSyntax) && !(node is AnonymousObjectCreationExpressionSyntax)) { var lambda = node as LambdaExpressionSyntax; if (lambda != null) { names.AddRange(lambda.SubOrFunctionHeader.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var indexer = node as PropertyBlockSyntax; if ((indexer != null) && (indexer.PropertyStatement.ParameterList != null)) { names.AddRange(indexer.PropertyStatement.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var methodDeclaration = node as MethodBlockSyntax; if (methodDeclaration != null) { names.AddRange(methodDeclaration.SubOrFunctionStatement.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var constructorDeclaration = node as ConstructorBlockSyntax; if (constructorDeclaration != null) { names.AddRange(constructorDeclaration.SubNewStatement.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var accessor = node as AccessorBlockSyntax; if (accessor != null) { if (accessor.IsKind(SyntaxKind.SetAccessorBlock) || accessor.IsKind(SyntaxKind.AddHandlerAccessorBlock) || accessor.IsKind(SyntaxKind.RemoveHandlerAccessorBlock)) { names.Add("value"); } var propertyParent = node.Parent as PropertyBlockSyntax; if ((propertyParent == null) || (propertyParent.PropertyStatement.ParameterList == null)) break; } node = node.Parent; } return names; }
private async Task<Document> ChangeToGenericAsync(CodeFixContext context, SyntaxNode root, ObjectCreationExpressionSyntax creation) { // Compute new uppercase name. var typeofSyntax = (TypeOfExpressionSyntax) creation.ArgumentList.Arguments[0].Expression; var type = typeofSyntax.Type; var originalEngine = creation.Type; var newRoot = root.ReplaceNode(creation, SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.ParseTypeName(originalEngine + "<" + type + ">"), SyntaxFactory.ArgumentList(), null)); return context.Document.WithSyntaxRoot(newRoot); }
public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { node = (ObjectCreationExpressionSyntax)base.VisitObjectCreationExpression(node); // new QueryParameter ("nr", DataType.String, referenceVersion.PatchNumber) var identifier = node.Type as IdentifierNameSyntax; if (identifier != null && identifier.HasTrailingTrivia) { this.addedAnnotations = true; return node.ReplaceNode(identifier, identifier.WithoutTrailingTrivia()); } return node; }
public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { if (IsChangeInObjectCreation) { return base.VisitObjectCreationExpression(node); } var found = FindListNode(node); if(found == null) { return base.VisitObjectCreationExpression(node); } ListToArrayReplacementRewriter rewriter = new ListToArrayReplacementRewriter(true); return rewriter.Visit(node); }
private IList<SignatureHelpItem> GetNormalTypeConstructors( Document document, ObjectCreationExpressionSyntax objectCreationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService, IDocumentationCommentFormattingService documentationCommentFormattingService, INamedTypeSymbol normalType, ISymbol within, CancellationToken cancellationToken) { var accessibleConstructors = normalType.InstanceConstructors .Where(c => c.IsAccessibleWithin(within)) .Where(s => s.IsEditorBrowsable(document.ShouldHideAdvancedMembers(), semanticModel.Compilation)) .Sort(symbolDisplayService, semanticModel, objectCreationExpression.SpanStart); return accessibleConstructors.Select(c => ConvertNormalTypeConstructor(c, objectCreationExpression, semanticModel, symbolDisplayService, anonymousTypeDisplayService, documentationCommentFormattingService, cancellationToken)).ToList(); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); ObjectCreationExpressionSyntax syntax = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <ObjectCreationExpressionSyntax>(); if (syntax == null) { return; } CodeAction codeAction = CodeAction.Create( "Add parentheses", cancellationToken => AddConstructorArgumentListRefactoring.RefactorAsync(context.Document, syntax, cancellationToken), DiagnosticIdentifiers.AddConstructorArgumentList + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
private static SyntaxToken? GetInvalidArgument( ObjectCreationExpressionSyntax creationToken, SemanticModel model) { foreach (var argument in creationToken.ArgumentList.Arguments) { var argumentExpression = argument.Expression as MemberAccessExpressionSyntax; if (argumentExpression != null) { var argumentSymbolNode = model.GetSymbolInfo(argumentExpression).Symbol; if (argumentSymbolNode.ContainingType.ToDisplayString() == Values.ExpectedContainingDateTimeKindTypeDisplayString) { return argumentExpression.Name.Identifier; } } } return null; }
private static void AddObjectCreationExpressionTerms(ObjectCreationExpressionSyntax objectionCreationExpression, IList <string> terms, ref ExpressionType expressionType) { // Object creation can *definitely* cause side effects. So we initially // mark this as something invalid. We allow it as a valid expr if all // the sub arguments are valid terms. expressionType = ExpressionType.Invalid; if (objectionCreationExpression.ArgumentList != null) { var flags = ExpressionType.Invalid; AddArgumentTerms(objectionCreationExpression.ArgumentList, terms, ref flags); // If all arguments are terms, then this is possibly a valid expr that can be used // somewhere higher in the stack. if (IsValidTerm(flags)) { expressionType = ExpressionType.ValidExpression; } } }
/// <summary> /// Try getting the <see cref="IMethodSymbol"/> for the node. /// Gets the semantic model for the tree if the node is not in the tree corresponding to <paramref name="semanticModel"/>. /// </summary> /// <param name="semanticModel">The <see cref="SemanticModel"/>.</param> /// <param name="node">The <see cref="ObjectCreationExpressionSyntax"/>.</param> /// <param name="expected">The expected method.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param> /// <param name="symbol">The symbol if found.</param> /// <returns>True if a symbol was found.</returns> public static bool TryGetSymbol(this SemanticModel semanticModel, ObjectCreationExpressionSyntax node, QualifiedType expected, CancellationToken cancellationToken, out IMethodSymbol symbol) { if (node.Type is SimpleNameSyntax typeName && (typeName.Identifier.ValueText == expected.Type || AliasWalker.TryGet(node.SyntaxTree, typeName.Identifier.ValueText, out _))) { symbol = semanticModel.GetSymbolSafe(node, cancellationToken); return(symbol?.ContainingType == expected); } if (node.Type is QualifiedNameSyntax qualifiedName && qualifiedName.Right.Identifier.ValueText == expected.Type) { symbol = semanticModel.GetSymbolSafe(node, cancellationToken); return(symbol?.ContainingType == expected); } symbol = null; return(false); }
public static void Analyze(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpression) { TypeSyntax type = objectCreationExpression.Type; InitializerExpressionSyntax initializer = objectCreationExpression.Initializer; if (type?.IsMissing == false && initializer?.IsMissing == false) { ArgumentListSyntax argumentList = objectCreationExpression.ArgumentList; if (argumentList == null) { var span = new TextSpan(type.Span.End, 1); context.ReportDiagnostic( DiagnosticDescriptors.AddConstructorArgumentList, Location.Create(context.SyntaxTree(), span)); } } }
private static InitializerExpressionSyntax CreateInitializer(ObjectCreationExpressionSyntax objectCreation, ExpressionStatementSyntax[] expressionStatements) { InitializerExpressionSyntax initializer = objectCreation.Initializer ?? SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression); var expressions = new AssignmentExpressionSyntax[expressionStatements.Length]; for (int i = 0; i < expressionStatements.Length; i++) { var assignment = (AssignmentExpressionSyntax)expressionStatements[i].Expression; var memberAccess = (MemberAccessExpressionSyntax)assignment.Left; expressions[i] = assignment.ReplaceNode(memberAccess, memberAccess.Name); } return(initializer .AddExpressions(expressions) .WithFormatterAnnotation()); }
public static bool IsDictionaryObjectCreationExpression(ObjectCreationExpressionSyntax node) { GenericNameSyntax genericObjectCreation = null; if (node.Type is QualifiedNameSyntax qns) { genericObjectCreation = qns.Right as GenericNameSyntax; } else { genericObjectCreation = node.Type as GenericNameSyntax; } if (genericObjectCreation == null) { return(false); } return(genericObjectCreation.ToString() == SupportedGenericDictionaryType); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); ObjectCreationExpressionSyntax objectCreationExpression = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <ObjectCreationExpressionSyntax>(); if (objectCreationExpression == null) { return; } CodeAction codeAction = CodeAction.Create( "Remove empty initializer", cancellationToken => RemoveEmptyInitializerRefactoring.RefactorAsync(context.Document, objectCreationExpression, cancellationToken), DiagnosticIdentifiers.RemoveEmptyInitializer + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public static SyntaxNode CreateUsing(SyntaxNode root, ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { SyntaxNode newRoot; var originalNode = objectCreation; var topSyntaxNode = (SyntaxNode)originalNode; while (topSyntaxNode.Parent.IsAnyKind(SyntaxKind.ParenthesizedExpression, SyntaxKind.ConditionalExpression, SyntaxKind.CastExpression)) { topSyntaxNode = topSyntaxNode.Parent; } if (topSyntaxNode.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression)) { var assignmentExpression = (AssignmentExpressionSyntax)topSyntaxNode.Parent; newRoot = CreateRootWithUsingFromSimpleAssigmentExpression(root, semanticModel, assignmentExpression); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.EqualsValueClause) && topSyntaxNode.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator)) { var variableDeclarator = (VariableDeclaratorSyntax)topSyntaxNode.Parent.Parent; newRoot = CreateRootWithUsingFromVaribleDeclaration(root, variableDeclarator); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.Argument)) { var identifierName = GetIdentifierName(originalNode, semanticModel); var childOfArgumentNode = topSyntaxNode; newRoot = CreateRootWithUsingFromArgument(root, (ExpressionSyntax)childOfArgumentNode, identifierName); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)) { var newVariableName = originalNode.Type.ToString(); var accessedNode = topSyntaxNode; newRoot = CreatRootWithUsingFromMemberAccessedNode(root, semanticModel, ref newVariableName, (ExpressionSyntax)accessedNode); } else { newRoot = CreateRootWithUsing(root, (ExpressionStatementSyntax)topSyntaxNode.Parent, u => u.WithExpression((ExpressionSyntax)topSyntaxNode)); } return(newRoot); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { Diagnostic diagnostic = context.Diagnostics[0]; if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.AddArgumentList)) { return; } SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, new TextSpan(context.Span.Start - 1, 0), out ObjectCreationExpressionSyntax objectCreation)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ISymbol symbol = semanticModel.GetSymbol(objectCreation.Type, context.CancellationToken); if (symbol?.IsErrorType() != false) { return; } CodeAction codeAction = CodeAction.Create( "Add argument list", cancellationToken => { ObjectCreationExpressionSyntax newNode = objectCreation.Update( objectCreation.NewKeyword, objectCreation.Type.WithoutTrailingTrivia(), SyntaxFactory.ArgumentList().WithTrailingTrivia(objectCreation.Type.GetTrailingTrivia()), objectCreation.Initializer); return(context.Document.ReplaceNodeAsync(objectCreation, newNode, cancellationToken)); }, GetEquivalenceKey(diagnostic)); context.RegisterCodeFix(codeAction, diagnostic); }
private static async Task <bool> HasPublicAddMethodAsync( RefactoringContext context, ExpressionSyntax expression, ObjectCreationExpressionSyntax objectCreationExpression) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ISymbol symbol = semanticModel .GetSymbolInfo(objectCreationExpression.Type, context.CancellationToken) .Symbol; if (symbol?.IsNamedType() == true) { foreach (ISymbol member in ((INamedTypeSymbol)symbol).GetMembers("Add")) { if (member.IsMethod() && !member.IsStatic && member.IsPublic()) { var methodSymbol = (IMethodSymbol)member; if (methodSymbol.Parameters.Length == 1) { ITypeSymbol expressionSymbol = semanticModel .GetTypeInfo(expression, context.CancellationToken) .ConvertedType; if (expressionSymbol != null && expressionSymbol.Equals(methodSymbol.Parameters[0].Type)) { return(true); } } return(true); } } } return(false); }
private SignatureHelpItem ConvertNormalTypeConstructor( IMethodSymbol constructor, ObjectCreationExpressionSyntax objectCreationExpression, SemanticModel semanticModel, IAnonymousTypeDisplayService anonymousTypeDisplayService, IDocumentationCommentFormattingService documentationCommentFormattingService, CancellationToken cancellationToken) { var position = objectCreationExpression.SpanStart; var item = CreateItem( constructor, semanticModel, position, anonymousTypeDisplayService, constructor.IsParams(), constructor.GetDocumentationPartsFactory(semanticModel, position, documentationCommentFormattingService), GetNormalTypePreambleParts(constructor, semanticModel, position), GetSeparatorParts(), GetNormalTypePostambleParts(constructor), constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken)).ToList()); return(item); }
public bool Analyze(ObjectCreationExpressionSyntax syntax) { // check if delegate constructor is boxing var semanticModel = compilation.GetSemanticModel(syntax.SyntaxTree); var type = semanticModel.GetTypeInfo(syntax).Type; if (type.TypeKind == TypeKind.Delegate && syntax.ArgumentList != null && syntax.ArgumentList.Arguments.Count != 0) { var argument = syntax.ArgumentList.Arguments[0]; var symbol = semanticModel.GetSymbolInfo(argument.Expression).Symbol; if (symbol is IMethodSymbol method) { if (IsInvalidDelegateMethod(method)) { FireSyntaxErrorCallback(syntax, boxingDelegateErrorMessage); return(false); } } } return(true); }
protected override IEnumerable <Diagnostic> AnalyzeObjectCreation(ObjectCreationExpressionSyntax node, SemanticModel semanticModel) { var argumentList = node.ArgumentList; if (argumentList is null) { return(Enumerable.Empty <Diagnostic>()); } var arguments = argumentList.Arguments; if (arguments.Count == 0) { return(Enumerable.Empty <Diagnostic>()); } return(arguments .Where(_ => _.Expression is LambdaExpressionSyntax) .Select(_ => ReportIssue(_.ToString(), _.GetLocation())) .ToList()); }
ULCall ExportExp(ObjectCreationExpressionSyntax es) { ULCall node = new ULCall(); node.Parent = currentBlock; node.callType = ULCall.ECallType.Constructor; if (es.ArgumentList != null) { foreach (var a in es.ArgumentList.Arguments) { node.Args.Add(ExportExp(a.Expression).GetOutputName(0)); } } node.Name = GetType(es.Type).FullName; //currentBlock.statements.Add(node); return(node); }
private VariableState VisitObjectCreation(ObjectCreationExpressionSyntax node, ExecutionState state) { VariableState finalState = VisitInvocationAndCreation(node, node.ArgumentList, state); foreach (SyntaxNode child in node.DescendantNodes()) { if (child is AssignmentExpressionSyntax assignmentExpressionSyntax) { var assignmentState = VisitAssignment(assignmentExpressionSyntax, state); MergeVariableState(assignmentExpressionSyntax.Left, assignmentState, state, finalState); } else { #if DEBUG Logger.Log(child.GetText().ToString().Trim() + " -> " + finalState); #endif } } return(finalState); }
private async Task <Document> FixParamAsync(Document document, ObjectCreationExpressionSyntax objectCreation, string newParamName, CancellationToken cancellationToken) { var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var type = objectCreation.Type; var typeSymbol = semanticModel.GetSymbolInfo(type).Symbol as ITypeSymbol; var argumentList = objectCreation.ArgumentList as ArgumentListSyntax; var paramNameLiteral = argumentList.Arguments[1].Expression as LiteralExpressionSyntax; var paramNameOpt = semanticModel.GetConstantValue(paramNameLiteral); var currentParamName = paramNameOpt.Value as string; var newLiteral = SyntaxFactory.ParseExpression(string.Format("\"{0}\"", newParamName)); var root = await document.GetSyntaxRootAsync(); var newRoot = root.ReplaceNode(paramNameLiteral, newLiteral); var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); }
public bool IsVulnerable(SemanticModel model, ObjectCreationExpressionSyntax syntax) { //Check for the type if (!ContainsTypeName(syntax)) { return(false); } //If we found it, verify the namespace var symbol = model.GetSymbolInfo(syntax).Symbol; if (!IsType(symbol)) { return(false); } //Pull the initialization expressions var initializer = syntax.Initializer; return(isValidPasswordComplexity(model, initializer)); }
private static bool IsReturnValueNotDelegate(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { var parent = objectCreation.GetSelfOrTopParenthesizedExpression().Parent; if (!(parent is ReturnStatementSyntax) && !(parent is LambdaExpressionSyntax)) { return(false); } var enclosing = semanticModel.GetEnclosingSymbol(objectCreation.SpanStart) as IMethodSymbol; if (enclosing == null) { return(false); } return(enclosing.ReturnType != null && !enclosing.ReturnType.Is(KnownType.System_Delegate)); }
public void OnStartup_ShouldInjectAWorkloadFileRepositoryInstanceIntoTheMainWindowAndShowIt() { var syntaxTree = CSharpSyntaxTree.ParseText(_appClassContent); var root = syntaxTree.GetRoot(); MethodDeclarationSyntax onStartupMethod = root.DescendantNodes().OfType <MethodDeclarationSyntax>() .FirstOrDefault(md => md.Identifier.ValueText.Equals("OnStartup")); Assert.That(onStartupMethod, Is.Not.Null, "Cannot find a method 'OnStartup' in App.xaml.cs"); List <ObjectCreationExpressionSyntax> objectCreations = onStartupMethod.DescendantNodes().OfType <ObjectCreationExpressionSyntax>().ToList(); ObjectCreationExpressionSyntax workloadFileRepositoryCreation = objectCreations.FirstOrDefault(oc => oc.Type.ToString() == nameof(WorkloadFileRepository)); Assert.That(workloadFileRepositoryCreation, Is.Not.Null, "Cannot find a statement in 'OnStartup' where a new instance of WorkloadFileRepository is created."); ObjectCreationExpressionSyntax mainWindowCreation = objectCreations.FirstOrDefault(oc => oc.Type.ToString() == nameof(MainWindow)); Assert.That(mainWindowCreation, Is.Not.Null, "Cannot find a statement in 'OnStartup' where a new instance of MainWindow is created."); var bodyBuilder = new StringBuilder(); //no pun intended :) foreach (var statement in onStartupMethod.Body.Statements) { bodyBuilder.AppendLine(statement.ToString()); } string body = bodyBuilder.ToString(); Assert.That(body, Contains.Substring("Environment.GetFolderPath"), "The folder to save workloads in, should be in the special 'AppData' directory. Use the 'Environment' class to retrieve the path of that directory."); Assert.That(body, Contains.Substring("Environment.SpecialFolder.ApplicationData"), "The folder to save workloads in, should be in the special 'AppData' directory. Use the 'Environment.SpecialFolder' enum."); Assert.That(body, Contains.Substring("Path.Combine(").And.Contains(@"""PlumberApp"")"), "The folder to save workloads in, should be a subdirectory 'PlumberApp' in the special 'AppData' directory. " + "Use the static 'Combine' method of the 'System.IO.Path' class to create a string that holds the complete directory path."); Assert.That(body, Contains.Substring(".Show();"), "The MainWindow is instantiated, but not shown in the 'OnStartup' method."); }
internal static bool TryGetDependencyProperty(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty fieldOrProperty) { fieldOrProperty = default; var invocation = objectCreation.FirstAncestorOrSelf <InvocationExpressionSyntax>(); if (invocation == null) { return(false); } if (DependencyProperty.TryGetRegisterCall(invocation, semanticModel, cancellationToken, out _) || DependencyProperty.TryGetRegisterReadOnlyCall(invocation, semanticModel, cancellationToken, out _) || DependencyProperty.TryGetRegisterAttachedCall(invocation, semanticModel, cancellationToken, out _) || DependencyProperty.TryGetRegisterAttachedReadOnlyCall(invocation, semanticModel, cancellationToken, out _)) { if (objectCreation.TryFirstAncestor <FieldDeclarationSyntax>(out var fieldDeclaration) && semanticModel.TryGetSymbol(fieldDeclaration, cancellationToken, out var field)) { return(BackingFieldOrProperty.TryCreateForDependencyProperty(field, out fieldOrProperty)); } if (objectCreation.TryFirstAncestor <PropertyDeclarationSyntax>(out var propertyDeclaration) && semanticModel.TryGetSymbol(propertyDeclaration, cancellationToken, out var property)) { return(BackingFieldOrProperty.TryCreateForDependencyProperty(property, out fieldOrProperty)); } return(false); } if (invocation.Expression is MemberAccessExpressionSyntax memberAccess && (DependencyProperty.TryGetAddOwnerCall(invocation, semanticModel, cancellationToken, out _) || DependencyProperty.TryGetOverrideMetadataCall(invocation, semanticModel, cancellationToken, out _)) && semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out ISymbol? candidate)) { return(BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out fieldOrProperty)); } return(false); }
/// <inheritdoc /> public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { if (this.SearchScope == SearchScope.Member) { base.VisitObjectCreationExpression(node); return; } if (this.visited.Add(node) && this.SemanticModel.TryGetSymbol(node, this.CancellationToken, out var target)) { if (this.SearchScope.IsEither(SearchScope.Instance, SearchScope.Type) && !target.ContainingType.Equals(this.ContainingType)) { base.VisitObjectCreationExpression(node); return; } if (target.ContainingType.TrySingleDeclaration(this.CancellationToken, out TypeDeclarationSyntax? containingTypeDeclaration)) { using (var walker = TypeDeclarationWalker.Borrow(containingTypeDeclaration)) { foreach (var initializer in walker.Initializers) { if (this.visited.Add(initializer)) { this.Visit(initializer); } } } } if (target.TrySingleDeclaration(this.CancellationToken, out ConstructorDeclarationSyntax? declaration)) { this.Visit(declaration); } base.VisitObjectCreationExpression(node); } }
public override LuaSyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node).Symbol; LuaExpressionSyntax creationExpression; if (symbol != null) { string codeTemplate = XmlMetaProvider.GetMethodCodeTemplate(symbol); if (codeTemplate != null) { creationExpression = BuildCodeTemplateExpression(codeTemplate, null, node.ArgumentList.Arguments.Select(i => i.Expression), symbol.TypeArguments); } else { var expression = (LuaExpressionSyntax)node.Type.Accept(this); var invokeExpression = BuildObjectCreationInvocation(symbol, expression); var arguments = BuildArgumentList(symbol, symbol.Parameters, node.ArgumentList); TryRemoveNilArgumentsAtTail(symbol, arguments); invokeExpression.AddArguments(arguments); creationExpression = invokeExpression; } } else { Contract.Assert(!node.ArgumentList.Arguments.Any()); var expression = (LuaExpressionSyntax)node.Type.Accept(this); var invokeExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.SystemNew, expression); creationExpression = invokeExpression; } if (node.Initializer == null) { return(creationExpression); } else { var functionExpression = BuildObjectInitializerExpression(node.Initializer); return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Create, creationExpression, functionExpression)); } }
public static void Analyze(SyntaxNodeAnalysisContext context, ObjectCreationExpressionSyntax objectCreationExpression) { if (objectCreationExpression.Type?.IsMissing == false && objectCreationExpression.Initializer?.IsMissing == false) { ArgumentListSyntax argumentList = objectCreationExpression.ArgumentList; if (argumentList?.Arguments.Any() == false) { SyntaxToken openParen = argumentList.OpenParenToken; SyntaxToken closeParen = argumentList.CloseParenToken; if (!openParen.IsMissing && !closeParen.IsMissing && openParen.TrailingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()) && closeParen.LeadingTrivia.All(f => f.IsWhitespaceOrEndOfLineTrivia())) { context.ReportDiagnostic(DiagnosticDescriptors.RemoveEmptyArgumentList, argumentList); } } } }
private ProgramState VisitObjectCreation(ObjectCreationExpressionSyntax ctor, ProgramState programState) { var newProgramState = programState.PopValues(ctor.ArgumentList?.Arguments.Count ?? 0); var sv = new SymbolicValue(); var ctorSymbol = SemanticModel.GetSymbolInfo(ctor).Symbol as IMethodSymbol; if (ctorSymbol == null) { // Add no constraint } else if (IsEmptyNullableCtorCall(ctorSymbol)) { newProgramState = sv.SetConstraint(ObjectConstraint.Null, newProgramState); } else { newProgramState = sv.SetConstraint(ObjectConstraint.NotNull, newProgramState); } return(newProgramState.PushValue(sv)); }
public static SyntaxNode CreateUsing(SyntaxNode root, ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { SyntaxNode newRoot; var originalNode = objectCreation; var topSyntaxNode = (SyntaxNode)originalNode; while (topSyntaxNode.Parent.IsAnyKind(SyntaxKind.ParenthesizedExpression, SyntaxKind.ConditionalExpression, SyntaxKind.CastExpression)) topSyntaxNode = topSyntaxNode.Parent; if (topSyntaxNode.Parent.IsKind(SyntaxKind.SimpleAssignmentExpression)) { var assignmentExpression = (AssignmentExpressionSyntax)topSyntaxNode.Parent; newRoot = CreateRootWithUsingFromSimpleAssigmentExpression(root, semanticModel, assignmentExpression); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.EqualsValueClause) && topSyntaxNode.Parent.Parent.IsKind(SyntaxKind.VariableDeclarator)) { var variableDeclarator = (VariableDeclaratorSyntax)topSyntaxNode.Parent.Parent; newRoot = CreateRootWithUsingFromVaribleDeclaration(root, variableDeclarator); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.Argument)) { var identifierName = GetIdentifierName(originalNode, semanticModel); var childOfArgumentNode = topSyntaxNode; newRoot = CreateRootWithUsingFromArgument(root, (ExpressionSyntax)childOfArgumentNode, identifierName); } else if (topSyntaxNode.Parent.IsKind(SyntaxKind.SimpleMemberAccessExpression)) { var newVariableName = originalNode.Type.ToString(); var accessedNode = topSyntaxNode; newRoot = CreatRootWithUsingFromMemberAccessedNode(root, semanticModel, ref newVariableName, (ExpressionSyntax)accessedNode); } else { newRoot = CreateRootWithUsing(root, (ExpressionStatementSyntax)topSyntaxNode.Parent, u => u.WithExpression((ExpressionSyntax)topSyntaxNode)); } return newRoot; }
private SignatureHelpItem ConvertNormalTypeConstructor( IMethodSymbol constructor, ObjectCreationExpressionSyntax objectCreationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService, IDocumentationCommentFormattingService documentationCommentFormattingService, CancellationToken cancellationToken) { var position = objectCreationExpression.SpanStart; var item = CreateItem( constructor, semanticModel, position, symbolDisplayService, anonymousTypeDisplayService, constructor.IsParams(), constructor.GetDocumentationParts(semanticModel, position, documentationCommentFormattingService, cancellationToken), GetNormalTypePreambleParts(constructor, semanticModel, position), GetSeparatorParts(), GetNormalTypePostambleParts(constructor), constructor.Parameters.Select(p => Convert(p, semanticModel, position, documentationCommentFormattingService, cancellationToken))); return item; }
private static bool IsAlreadyStatic(ObjectCreationExpressionSyntax objectCreationExpr) { var result = false; var memberForObjectCreationExpr = objectCreationExpr.FirstAncestorOrSelfThatIsAMember(); switch (memberForObjectCreationExpr.Kind()) { case SyntaxKind.ConstructorDeclaration: var constructorDeclaration = (ConstructorDeclarationSyntax)memberForObjectCreationExpr; result = ContainsStaticModifier(constructorDeclaration.Modifiers); break; case SyntaxKind.FieldDeclaration: var fieldDeclaration = (FieldDeclarationSyntax)memberForObjectCreationExpr; result = ContainsStaticModifier(fieldDeclaration.Modifiers); break; default: break; } return(result); }
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { base.VisitObjectCreationExpression(node); //var text = node.ToString(); var type = node.Type.ToString(); if ((from db in this.FoundContexts where db.Name == type.Split('.').LastOrDefault() select db).Any()) { //Console.WriteLine(text); //Console.WriteLine(type); var identifer = ((Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax)node.Parent.Parent).Identifier; var varName = identifer.Value; //Console.WriteLine(varName); //Console.WriteLine(node.Span); //Console.WriteLine(); createList.Add(node, varName.ToString()); } }
private bool TryGenerateNewClass(ObjectCreationExpressionSyntax objectCreationExpression) { if (!(SemanticModel.GetSymbolInfo(objectCreationExpression.Type).Symbol is ITypeSymbol type)) { return(false); } using (NewClassTag()) { GenerateType(type); foreach (var argument in objectCreationExpression.ArgumentList.Arguments) { if (!TryGenerateArgument(argument)) { return(false); } } } return(true); }
static VariableDeclarationSyntax DeclareVariable(this IVariableDeclarationModel decl, RoslynTranslator translator, bool useInitialization, bool isField) { bool canBeImplicitlyTyped = !isField; bool initialized = false; var varDeclarator = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(decl.VariableName)); if (useInitialization && translator.Stencil.GetVariableInitializer().RequiresInitialization(decl)) { if (decl.InitializationModel != null) { var expression = translator.BuildNode(decl.InitializationModel).SingleOrDefault() as ExpressionSyntax; varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(expression)); initialized = true; } else if (decl.DataType.IsVsArrayType(translator.Stencil)) { ObjectCreationExpressionSyntax exp = SyntaxFactory.ObjectCreationExpression( TypeSystem.BuildTypeSyntax(decl.DataType.Resolve(translator.Stencil))) .WithArgumentList(SyntaxFactory.ArgumentList()); varDeclarator = varDeclarator.WithInitializer(SyntaxFactory.EqualsValueClause(exp)); initialized = true; } } VariableDeclarationSyntax varDeclaration; if (canBeImplicitlyTyped && initialized) { varDeclaration = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var")); } else { varDeclaration = SyntaxFactory.VariableDeclaration(decl.DataType.ToTypeSyntax(translator.Stencil)); } return(varDeclaration.WithVariables(SyntaxFactory.SingletonSeparatedList(varDeclarator))); }
public VulnerableSyntaxNode Create(ObjectCreationExpressionSyntax syntaxNode, params string[] messageArgs) { if (syntaxNode == null) { throw new ArgumentNullException(nameof(syntaxNode)); } var sources = new List <SyntaxNode>(); //Standard arguments passed into a constructor if (syntaxNode.ArgumentList != null && syntaxNode.ArgumentList.Arguments.Any()) { sources.AddRange(syntaxNode.ArgumentList.Arguments.ToArray().Select(p => p.Expression)); } //Initializer arguments passed in via the inline syntax object = new object() { x = y; } if (syntaxNode.Initializer != null) { sources.AddRange(syntaxNode.Initializer.Expressions); } return(new VulnerableSyntaxNode(syntaxNode, sources.ToImmutableArray(), messageArgs)); }
private static bool IsInArgumentAndCanBeChanged(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, Func <InvocationExpressionSyntax, bool> additionalFilter = null) { var parent = objectCreation.GetSelfOrTopParenthesizedExpression().Parent; var argument = parent as ArgumentSyntax; var invocation = argument?.Parent?.Parent as InvocationExpressionSyntax; if (invocation == null) { return(false); } if (additionalFilter != null && additionalFilter(invocation)) { return(false); } var methodSymbol = semanticModel.GetSymbolInfo(invocation).Symbol; if (methodSymbol == null) { return(false); } var newArgumentList = SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList(invocation.ArgumentList.Arguments .Select(a => a == argument ? SyntaxFactory.Argument(objectCreation.ArgumentList.Arguments.First().Expression) : a))); var newInvocation = invocation.WithArgumentList(newArgumentList); SemanticModel newSemanticModel; newInvocation = ChangeSyntaxElement(invocation, newInvocation, semanticModel, out newSemanticModel); var newMethodSymbol = newSemanticModel.GetSymbolInfo(newInvocation).Symbol as IMethodSymbol; return(newMethodSymbol != null && methodSymbol.ToDisplayString() == newMethodSymbol.ToDisplayString()); }
private Task<Solution> UseNameofAsync(Document document, SyntaxNode root, ObjectCreationExpressionSyntax objectCreationExpression) { var method = objectCreationExpression.Ancestors().OfType<MethodDeclarationSyntax>().First(); var methodParameters = method.ParameterList.Parameters; var expressionArguments = objectCreationExpression.ArgumentList.Arguments.Select(x => x.Expression).OfType<LiteralExpressionSyntax>(); foreach (var expressionArgument in expressionArguments) { foreach (var methodParameter in methodParameters) { if (string.Equals((string) methodParameter.Identifier.Value, (string) expressionArgument.Token.Value, StringComparison.OrdinalIgnoreCase)) { var newExpression = SyntaxFactory.ParseExpression($"nameof({methodParameter.Identifier})"); var newParent = objectCreationExpression.ReplaceNode(expressionArgument, newExpression); var newRoot = root.ReplaceNode(objectCreationExpression, newParent); var newDocument = document.WithSyntaxRoot(newRoot); return Task.FromResult(newDocument.Project.Solution); } } } return null; }
internal static bool CheckExceptionType(SemanticModel model, ObjectCreationExpressionSyntax objectCreateExpression, out ExpressionSyntax paramNode, out ExpressionSyntax altParam, out bool canAddParameterName) { paramNode = null; altParam = null; canAddParameterName = false; var type = model.GetTypeInfo(objectCreateExpression).Type; if (type == null) return false; if (type.Name == typeof(ArgumentException).Name) { if (objectCreateExpression.ArgumentList.Arguments.Count >= 2) { altParam = objectCreateExpression.ArgumentList.Arguments[0].Expression; paramNode = objectCreateExpression.ArgumentList.Arguments[1].Expression; } return paramNode != null; } if (type.Name == typeof(ArgumentNullException).Name || type.Name == typeof(ArgumentOutOfRangeException).Name || type.Name == "DuplicateWaitObjectException") { canAddParameterName = objectCreateExpression.ArgumentList.Arguments.Count == 1; if (objectCreateExpression.ArgumentList.Arguments.Count >= 1) { paramNode = objectCreateExpression.ArgumentList.Arguments[0].Expression; if (objectCreateExpression.ArgumentList.Arguments.Count == 2) { altParam = objectCreateExpression.ArgumentList.Arguments[1].Expression; if (model.GetTypeInfo(altParam).Type?.SpecialType != SpecialType.System_String) paramNode = null; } if (objectCreateExpression.ArgumentList.Arguments.Count == 3) altParam = objectCreateExpression.ArgumentList.Arguments[2].Expression; } return paramNode != null; } return false; }
internal static string GuessParameterName(SemanticModel model, ObjectCreationExpressionSyntax objectCreateExpression, List<string> validNames) { if (validNames.Count == 1) return validNames[0]; var parent = objectCreateExpression.Ancestors().OfType<IfStatementSyntax>().FirstOrDefault(); if (parent == null) return null; return GetParameterName(model, parent.Condition); }
internal static List<string> GetValidParameterNames(ObjectCreationExpressionSyntax objectCreateExpression) { var names = new List<string>(); var node = objectCreateExpression.Parent; while (node != null && !(node is BaseTypeDeclarationSyntax) && !(node is AnonymousObjectCreationExpressionSyntax)) { var lambda = node as ParenthesizedLambdaExpressionSyntax; if (lambda != null) names.AddRange(lambda.ParameterList.Parameters.Select(p => p.Identifier.ToString())); var lambda2 = node as SimpleLambdaExpressionSyntax; if (lambda2 != null && lambda2.Parameter != null) names.Add(lambda2.Parameter.Identifier.ToString()); var anonymousMethod = node as AnonymousMethodExpressionSyntax; if (anonymousMethod != null) names.AddRange(anonymousMethod.ParameterList.Parameters.Select(p => p.Identifier.ToString())); var indexer = node as IndexerDeclarationSyntax; if (indexer != null) { names.AddRange(indexer.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var convOperator = node as ConversionOperatorDeclarationSyntax; if (convOperator != null) { names.AddRange(convOperator.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var op = node as OperatorDeclarationSyntax; if (op != null) { names.AddRange(op.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var methodDeclaration = node as MethodDeclarationSyntax; if (methodDeclaration != null) { names.AddRange(methodDeclaration.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var constructorDeclaration = node as ConstructorDeclarationSyntax; if (constructorDeclaration != null) { names.AddRange(constructorDeclaration.ParameterList.Parameters.Select(p => p.Identifier.ToString())); break; } var accessor = node as AccessorDeclarationSyntax; if (accessor != null) { if (accessor.IsKind(SyntaxKind.SetAccessorDeclaration) || accessor.IsKind(SyntaxKind.AddAccessorDeclaration) || accessor.IsKind(SyntaxKind.RemoveAccessorDeclaration)) { names.Add("value"); } if (!accessor.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration)) { break; } } node = node.Parent; } return names; }
private static SyntaxToken? GetIdentifier(ObjectCreationExpressionSyntax objectCreationExpressionSyntax) { switch (objectCreationExpressionSyntax.Type.Kind()) { case SyntaxKind.QualifiedName: var qualifiedNameSyntax = (QualifiedNameSyntax)objectCreationExpressionSyntax.Type; var identifierNameSyntax = qualifiedNameSyntax.DescendantNodes().OfType<IdentifierNameSyntax>().LastOrDefault(); return identifierNameSyntax?.Identifier; case SyntaxKind.IdentifierName: return ((IdentifierNameSyntax)objectCreationExpressionSyntax.Type).Identifier; case SyntaxKind.GenericName: return ((GenericNameSyntax)objectCreationExpressionSyntax.Type).Identifier; default: return null; } }
/// <summary> /// Resolves the side effects from the given object creation summary. /// </summary> /// <param name="call">Call</param> /// <param name="summary">MethodSummary</param> /// <param name="syntaxNode">SyntaxNode</param> /// <param name="cfgNode">ControlFlowGraphNode</param> /// <param name="model">SemanticModel</param> /// <param name="dataFlowMap">DataFlowMap</param> /// <returns>Set of reachable field symbols</returns> private static HashSet<ISymbol> ResolveSideEffectsInCall(ObjectCreationExpressionSyntax call, MethodSummary summary, SyntaxNode syntaxNode, ControlFlowGraphNode cfgNode, SemanticModel model, DataFlowMap dataFlowMap) { if (summary == null) { return new HashSet<ISymbol>(); } HashSet<ISymbol> reachableFields = new HashSet<ISymbol>(); var sideEffects = summary.GetResolvedSideEffects(call.ArgumentList, model); foreach (var sideEffect in sideEffects) { dataFlowMap.MapRefsToSymbol(sideEffect.Value, sideEffect.Key, syntaxNode, cfgNode); reachableFields.Add(sideEffect.Key); } foreach (var fieldAccess in summary.FieldAccessSet) { foreach (var access in fieldAccess.Value) { if (cfgNode.Summary.FieldAccessSet.ContainsKey(fieldAccess.Key as IFieldSymbol)) { cfgNode.Summary.FieldAccessSet[fieldAccess.Key as IFieldSymbol].Add(access); } else { cfgNode.Summary.FieldAccessSet.Add(fieldAccess.Key as IFieldSymbol, new HashSet<SyntaxNode>()); cfgNode.Summary.FieldAccessSet[fieldAccess.Key as IFieldSymbol].Add(access); } } } return reachableFields; }
private static string GetIdentifierName(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel) { var identifierName = "disposableObject"; var type = objectCreation.Type; if (type.IsKind(SyntaxKind.QualifiedName)) { var name = (QualifiedNameSyntax)type; identifierName = LowerCaseFirstLetter(name.Right.Identifier.ValueText); } else if (type is SimpleNameSyntax) { var name = (SimpleNameSyntax)type; identifierName = LowerCaseFirstLetter(name.Identifier.ValueText); } var confilctingNames = from symbol in semanticModel.LookupSymbols(objectCreation.SpanStart) let symbolIdentifierName = symbol?.ToDisplayParts().LastOrDefault(AnalyzerExtensions.IsName).ToString() where symbolIdentifierName != null && symbolIdentifierName.StartsWith(identifierName) select symbolIdentifierName; var identifierPostFix = 0; while (confilctingNames.Any(p => p == identifierName + ++identifierPostFix)) { } return identifierName + (identifierPostFix == 0 ? "" : identifierPostFix.ToString()); }
/// <summary> /// Returns the return symbols fromt he given object creation summary. /// </summary> /// <param name="call">Call</param> /// <param name="summary">MethodSummary</param> /// <param name="model">SemanticModel</param> /// <returns>Set of return symbols</returns> private static HashSet<ISymbol> GetReturnSymbols(ObjectCreationExpressionSyntax call, MethodSummary summary, SemanticModel model) { if (summary == null) { return new HashSet<ISymbol>(); } return summary.GetResolvedReturnSymbols(call.ArgumentList, model); }