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);
}
