public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { CheckThrowKeyword(node); foreach (var n in node.ChildNodes()) { Visit(n); } }
private Task <Document> UseNewGuid(Document document, SyntaxNode root, ObjectCreationExpressionSyntax statement) { // We're not adding the simplifier in this route because it doesn't seem to work // It works when putting it on the root node but that has too many consequences for other code // We do some simple introspection to see if it is fully qualified already or not var newExpression = "Guid.NewGuid()"; if (statement.ChildNodes().First().IsKind(SyntaxKind.QualifiedName)) { newExpression = "System.Guid.NewGuid()"; } var newRoot = root.ReplaceNode(statement, SyntaxFactory.ParseExpression(newExpression)); return(Task.FromResult(document.WithSyntaxRoot(newRoot))); }
/* Method that checks whether or not Singleton class is thread safe * by way of double check locking */ public bool IsDoubleCheckLocked(ClassDeclarationSyntax classDec) { /* List of methods that might be used to * return instances of singleton class */ List <MethodDeclarationSyntax> possibleInstanceMethods = new List <MethodDeclarationSyntax>(); // Get List of all methodDeclarations in class List <MethodDeclarationSyntax> methodDeclarations = classDec.DescendantNodes(). OfType <MethodDeclarationSyntax>().ToList(); bool classContainsValidMethod = false; foreach (MethodDeclarationSyntax methodDec in methodDeclarations) { bool isPublic = false; bool isStatic = false; /* Check if method returns an instance of class first, * otherwise don't do more taxing operations */ if (methodDec.ReturnType.ToString(). Equals(classDec.Identifier.Text)) { /* Check whether or not method is public and static, * both of which instance method should be */ SyntaxTokenList modifiers = methodDec.Modifiers; foreach (SyntaxToken modifier in modifiers) { if (modifier.IsKind(SyntaxKind.PublicKeyword)) { isPublic = true; } else if (modifier.IsKind(SyntaxKind.StaticKeyword)) { isStatic = true; } } } /* isPublic and isStatic can only have been changed to true * if returnType is correct. If conditions are fulfilled, * add checked method to list of possible instance methods */ if (isPublic && isStatic) { possibleInstanceMethods.Add(methodDec); } } foreach ( MethodDeclarationSyntax methodDec in possibleInstanceMethods) { /* Can choose .First() because method can * syntactically only have one Block */ BlockSyntax block = methodDec.ChildNodes(). OfType <BlockSyntax>().First(); string identifier = ""; bool containsFirstCheck = false; List <SyntaxNode> nodes = block.ChildNodes().OfType <SyntaxNode>().ToList(); BlockSyntax secondBlock = null; foreach (SyntaxNode node in nodes) { /* Check whether or not the block contains an if-stmt * that checks the instance variable for null */ if (node.IsKind(SyntaxKind.IfStatement)) { List <SyntaxNodeOrToken> subNodes = node.ChildNodesAndTokens(). OfType <SyntaxNodeOrToken>().ToList(); bool isEqualsEquals = false; bool checksForNull = false; foreach (SyntaxNodeOrToken subNode in subNodes) { if (subNode.IsKind(SyntaxKind.EqualsExpression)) { List <SyntaxNodeOrToken> subSubNodes = subNode.ChildNodesAndTokens(). OfType <SyntaxNodeOrToken>().ToList(); foreach ( SyntaxNodeOrToken subSubNode in subSubNodes) { if (subSubNode.IsKind( SyntaxKind.IdentifierName)) { identifier = subSubNode.ToString(); } else if (subSubNode.IsKind( SyntaxKind.EqualsEqualsToken)) { isEqualsEquals = true; } else if (subSubNode.IsKind( SyntaxKind.NullLiteralExpression)) { checksForNull = true; } } } } if (isEqualsEquals && checksForNull) { containsFirstCheck = true; secondBlock = node.ChildNodes(). OfType <BlockSyntax>().First(); } } } bool containsLock = false; BlockSyntax thirdBlock = null; /* If instance variable is checked for null first, * check if after that check, a lock occurs */ if (containsFirstCheck) { List <SyntaxNode> subNodes = secondBlock.ChildNodes().OfType <SyntaxNode>().ToList(); foreach (SyntaxNode subNode in subNodes) { if (subNode.IsKind(SyntaxKind.LockStatement)) { containsLock = true; thirdBlock = subNode.ChildNodes(). OfType <BlockSyntax>().First(); } } } bool containsSecondCheck = false; BlockSyntax fourthBlock = null; /* If the lock occurs, check if another * null-check on instance variable happens */ if (containsLock) { List <SyntaxNode> subNodes = thirdBlock.ChildNodes(). OfType <SyntaxNode>().ToList(); foreach (SyntaxNode subNode in subNodes) { if (subNode.IsKind( SyntaxKind.IfStatement)) { List <SyntaxNode> subSubNodes = subNode.ChildNodes(). OfType <SyntaxNode>().ToList(); foreach (SyntaxNode subSubNode in subSubNodes) { if (subSubNode.IsKind( SyntaxKind.EqualsExpression)) { List <SyntaxNodeOrToken> subSubSubNodes = subSubNode.ChildNodesAndTokens(). OfType <SyntaxNodeOrToken>().ToList(); bool correctIdentifier = false; bool isEqualsEquals = false; bool checksForNull = false; foreach ( SyntaxNodeOrToken subSubSubNode in subSubSubNodes) { if (subSubSubNode.IsKind( SyntaxKind.IdentifierName) && subSubSubNode.ToString() == identifier) { correctIdentifier = true; } else if (subSubSubNode.IsKind( SyntaxKind.EqualsEqualsToken)) { isEqualsEquals = true; } else if (subSubSubNode.IsKind( SyntaxKind.NullLiteralExpression)) { checksForNull = true; } } if (correctIdentifier && isEqualsEquals && checksForNull) { containsSecondCheck = true; fourthBlock = subNode.ChildNodes(). OfType <BlockSyntax>().First(); } } } } } } bool isValidDoubleCheck = false; /* If second null-check happens, finally check whether or not * after that second null-check, a value is assigned to * the instance variable of type {ClassName} * in which case it can be determined that a valid * double check lock has occured */ if (containsSecondCheck) { List <SyntaxNode> subNodes = fourthBlock.ChildNodes(). OfType <SyntaxNode>().ToList(); foreach (SyntaxNode subNode in subNodes) { if (subNode.IsKind(SyntaxKind.ExpressionStatement)) { List <SyntaxNode> subSubNodes = subNode.ChildNodes(). OfType <SyntaxNode>().ToList(); foreach (SyntaxNode subSubNode in subSubNodes) { if (subSubNode.IsKind (SyntaxKind.SimpleAssignmentExpression)) { /* SimpleAssignmentExpression can * only have an identifier name */ if (subSubNode.ChildNodes(). OfType <IdentifierNameSyntax>(). First().Identifier.Text == identifier) { /* Only one ObjectCreationExpression * can be attached to a * SimpleAssignmentExpression */ ObjectCreationExpressionSyntax objectCreationExp = subSubNode.ChildNodes(). OfType <ObjectCreationExpressionSyntax>(). First(); /* ObjectCreationExpression can only * have one IdentifierName * attached to it */ if (objectCreationExp.ChildNodes(). OfType <IdentifierNameSyntax>(). First().Identifier.Text == classDec.Identifier.Text) { isValidDoubleCheck = true; } } } } } } if (isValidDoubleCheck) { classContainsValidMethod = true; } } } return(classContainsValidMethod); }