private static async Task<Document> MakeMock(Document document, SyntaxNode invokationSyntax,
CancellationToken cancellationToken)
{
var testSemanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var testInitMethodDecl = TestSemanticHelper.GetTestInitializeMethod(testSemanticModel);
var declaredFields = testInitMethodDecl.Parent.ChildNodes().OfType<FieldDeclarationSyntax>().ToArray();
var suts = testInitMethodDecl.GetSuts(testSemanticModel, declaredFields);
var memberAccessExpressions = invokationSyntax.DescendantNodes()
.OfType<ExpressionSyntax>()
.Where(x => x is InvocationExpressionSyntax || x is MemberAccessExpressionSyntax)
.Select(expr =>
{
var memberAccess = expr as MemberAccessExpressionSyntax;
var invokationExpression = expr as InvocationExpressionSyntax;
var expression = invokationExpression == null ? memberAccess : invokationExpression.Expression;
return expression;
});
var invokedMethodsOfMocks = memberAccessExpressions.SelectMany(expressionSyntax => MocksAnalyzingEngine.GetInvokedMethodsOfMock(expressionSyntax, testSemanticModel, suts))
.DistinctBy(x => string.Join(",", x.FieldsToSetup.SelectMany(y => y.Field.Select(z => z))) + "," + x.MethodOrPropertySymbol)
.ToArray();
if (invokedMethodsOfMocks.Length == 0)
return document;
var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
ChangesMaker.ApplyChanges(invokationSyntax, editor, invokedMethodsOfMocks);
return editor.GetChangedDocument();
}
private static IEnumerable<NameAndLocation> GetAllMutations(SyntaxNode syntax)
{
var assignments = syntax.DescendantNodes()
.Where(NodeIsAssignmentExpression)
.Cast<AssignmentExpressionSyntax>()
.Select(expression => new NameAndLocation(
GetIdentifierFromAssignmentExpression(expression),
expression.GetLocation()));
var prefixExpressions = syntax.DescendantNodes()
.Where(NodeIsPrefixExpression)
.Cast<PrefixUnaryExpressionSyntax>()
.Select(expression => new NameAndLocation(
GetIdentifierFromPrefixOperand(expression),
expression.GetLocation()));
var postfixExpressions = syntax.DescendantNodes()
.Where(NodeIsPostfixExpression)
.Cast<PostfixUnaryExpressionSyntax>()
.Select(expression => new NameAndLocation(
GetIdentifierFromPostfixOperand(expression),
expression.GetLocation()));
return assignments.Cons(prefixExpressions).Cons(postfixExpressions);
}
private int GetExerciseInsertIndex(SyntaxNode tree)
{
ClassDeclarationSyntax exerciseClass =
tree.DescendantNodes()
.OfType<ClassDeclarationSyntax>()
.FirstOrDefault(n => n.Identifier.Text == ExerciseClassName);
if (exerciseClass !=null)
return exerciseClass.OpenBraceToken.Span.End;
var ns = tree.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
if (ns != null)
return ns.OpenBraceToken.Span.End;
return 0;
}
private static SyntaxNode Normalize(SyntaxNode root, IEnumerable<SyntaxNode> members, Scope scope)
{
var appClass = root
.DescendantNodes()
.OfType<ClassDeclarationSyntax>()
.Where(@class => @class.Identifier.ToString() == "testclass")
.FirstOrDefault();
if (appClass == null)
appClass = CSharp.ClassDeclaration("testclass");
return CSharp.CompilationUnit()
.WithMembers(CSharp.List(new[] {(MemberDeclarationSyntax)
appClass
.WithMembers(CSharp.List(
members.Select(
member => {
var method = member as MethodDeclarationSyntax;
if (method == null)
return member;
return method.WithParameterList(
method
.ParameterList
.AddParameters(CSharp.Parameter(
CSharp.ParseToken("result"))
.WithType(CSharp.ParseTypeName("Dictionary<string, object>"))));})))}));
}
private static void FindViolatingAssignments(SyntaxNodeAnalysisContext context, SyntaxNode syntaxNode, SyntaxToken identifier)
{
IEnumerable<AssignmentExpressionSyntax> assignments = syntaxNode.DescendantNodes().OfType<AssignmentExpressionSyntax>();
foreach (var violatingAssignment in assignments.Where(ass => ass.Left is IdentifierNameSyntax
&& ((IdentifierNameSyntax)ass.Left).Identifier.Value == identifier.Value))
context.ReportDiagnostic(Diagnostic.Create(Rule, violatingAssignment.GetLocation()));
}
public static bool VariableExists(SyntaxNode root, params string[] variableNames)
{
return root
.DescendantNodes()
.OfType<VariableDeclarationSyntax>()
.SelectMany(ps => ps.DescendantTokens().Where(t => t.IsKind(SyntaxKind.IdentifierToken) && variableNames.Contains(t.ValueText)))
.Any();
}
public bool inheritsFromController(SyntaxNode root, String args)
{
bool isValid = false;
try
{
isValid = root.DescendantNodes().OfType<BaseTypeSyntax>().First().ToString().Equals("ApiController") ||
root.DescendantNodes().OfType<BaseTypeSyntax>().First().ToString().Equals("Controller");
}
catch (InvalidOperationException)
{
isValid = false;
}
return isValid;
}
private static bool IsMethodUsed(MethodDeclarationSyntax methodTarget, SyntaxNode typeDeclaration)
{
var descendents = typeDeclaration.DescendantNodes();
var hasIdentifier = descendents.OfType<IdentifierNameSyntax>();
if (hasIdentifier.Any(a => a != null && a.Identifier.ValueText.Equals(methodTarget.Identifier.ValueText)))
return true;
var genericNames = descendents.OfType<GenericNameSyntax>();
return genericNames.Any(n => n != null && n.Identifier.ValueText.Equals(methodTarget.Identifier.ValueText));
}
public static void ClassInitialize(TestContext context)
{
var tree = CSharpSyntaxTree.ParseText(source);
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var compilation = CSharpCompilation.Create(nameof(GetVariableString), new[] { tree }, new[] { mscorlib });
semanticModel = compilation.GetSemanticModel(tree);
syntaxRoot = tree.GetRoot();
method1 = syntaxRoot.DescendantNodes().OfType<MethodDeclarationSyntax>().First();
invocations = method1.Body.ChildNodes().OfType<ExpressionStatementSyntax>().Select(x => x.Expression as InvocationExpressionSyntax).ToArray();
}
private async Task<Solution> MoveToMatchingFileAsync(Document document, SyntaxNode syntaxTree, TypeDeclarationSyntax declaration, CancellationToken cancellationToken)
{
var otherTypeDeclarationsInFile = syntaxTree.DescendantNodes().Where(originalNode => TypeDeclarationOtherThan(declaration, originalNode)).ToList();
string newFilePath = GetNewFilePath(document, declaration);
var newDocumentSyntaxTree = GetNewDocumentSyntaxTree(syntaxTree, otherTypeDeclarationsInFile);
var newFile = document.Project.AddDocument(newFilePath, newDocumentSyntaxTree.GetText(), document.Folders);
var solutionWithClassRemoved = GetDocumentWithClassDeclarationRemoved(newFile.Project, document, syntaxTree, declaration, otherTypeDeclarationsInFile);
return document.Project.RemoveDocument(document.Id).Solution;
}
public void IsCreateTaskInLoop(SyntaxNode node)
{
if (node.DescendantNodes().OfType<IdentifierNameSyntax>().Any(a => "StartNew".Equals(a.ToString()))
&& !node.ToString().Contains("Stopwatch"))
{
if (Id.ToLower().Contains("test"))
Helper.WriteInstance(LoopTaskTestFile, Id, node.Parent.ToString());
else
Helper.WriteInstance(LoopTaskFile, Id, node.Parent.ToString());
}
}
private static SyntaxNode CreateExtensionClass(SyntaxNode root, Scope scope)
{
if (!root
.DescendantNodes()
.OfType<ClassDeclarationSyntax>()
.Where(@class => @class.Identifier.ToString() == "Extension")
.Any())
return ExtensionClass;
return root;
}
internal static IEnumerable<ExpandablePropertyInfo> GetExpandableProperties(TextSpan span, SyntaxNode root, SemanticModel model)
{
var propertiesInTypes = root.DescendantNodes(span)
.OfType<PropertyDeclarationSyntax>()
.Select(p => GetExpandablePropertyInfo(p, model))
.Where(p => p != null)
.GroupBy(p => p.PropertyDeclaration.FirstAncestorOrSelf<TypeDeclarationSyntax>());
return propertiesInTypes.Any()
? propertiesInTypes.First()
: Enumerable.Empty<ExpandablePropertyInfo>();
}
//--- Class Methods ---
public static IEnumerable<ISymbol> GetMissingEnumMembers(SyntaxNode switchNode, SemanticModel semanticModel, out IdentifierNameSyntax switchVariable)
{
switchVariable = switchNode.DescendantNodes().OfType<IdentifierNameSyntax>().First();
var switchVariableTypeInfo = semanticModel.GetTypeInfo(switchVariable);
// check if we are switching over an enum
if(switchVariableTypeInfo.Type.TypeKind == TypeKind.Enum) {
// get all the enum values
var enumMembers = switchVariableTypeInfo.Type.GetMembers().Where(x => x.Kind == SymbolKind.Field).ToImmutableArray();
// get all case statements
var caseSwitchLabels = switchNode
.DescendantNodes().OfType<CaseSwitchLabelSyntax>()
.Select(x => x.DescendantNodes().OfType<MemberAccessExpressionSyntax>().FirstOrDefault())
.Where(x => x != null)
.Select(x => semanticModel.GetSymbolInfo(x).Symbol)
.ToImmutableHashSet();
// make sure we have all cases covered
return enumMembers.Where(x => !caseSwitchLabels.Contains(x)).ToImmutableArray();
}
return Enumerable.Empty<ISymbol>();
}
/// <summary>
/// checks if the documentation from the class member is the same as the one
/// from the mixin member.
/// This only works if both have only one member
/// </summary>
/// <param name="classDeclaration"></param>
/// <param name="mixin"></param>
/// <returns>true if member documentation is identical, false otherwise</returns>
public static bool HasSameDocumentation(SyntaxNode classDeclaration, MixinReference mixin)
{
var documentationFromChild = classDeclaration
.DescendantNodes(descendIntoTrivia: true)
.Last(x => x is DocumentationCommentTriviaSyntax)
.GetText().ToString();
// get generated documentation from mixin
var documentationFromMixin =
mixin
.Class
.MembersFromThisAndBase
.Single()
.Documentation
.ToString();
return documentationFromChild == documentationFromMixin;
}
internal bool LockCheckinSimpleMemberAccess(SyntaxNode usingBlock)
{
if (reportedIssue) return false;
var simpleMembers = usingBlock.DescendantNodes().OfType<MemberAccessExpressionSyntax>();
string expression = GetVariableName() + ".LockApplied";
int checksOnLock = 0;
if (simpleMembers.Count() > 0)
{
checksOnLock = simpleMembers.Where(n => n.ToString() == expression).Count();
}
if(checksOnLock == 0)
{
ReportIssue("there is no check in the using block whether the lock was successful");
}
return checksOnLock > 0;
}
public static IEnumerable<IGrouping<ISymbol, ReferenceLocation>> Resolve(this Compilation compilation, SyntaxNode root)
{
var model = compilation.GetSemanticModel(root.SyntaxTree);
var fields = root.DescendantNodes()
.Select(
descendant =>
{
var symbol = model.GetSymbolInfo(descendant);
return new KeyValuePair<ISymbol, SyntaxNode>(symbol.Symbol, descendant);
})
.Where(x => x.Key != null)
.SelectMany(x => GetSymbolDetails(x, model))
.GroupBy(x => x.Symbol, x => x.Location);
var array = fields.AsArray();
return array;
}
public async Task<IEnumerable<ValidationMessage>> ProcessAsync(Document document, SyntaxNode syntaxRoot, CancellationToken cancellationToken)
{
List<ValidationMessage> messages = new List<ValidationMessage>();
var model = document.GetSemanticModelAsync();
// Find all variable declarations
var decls = syntaxRoot.DescendantNodes().OfType<LocalDeclarationStatementSyntax>();
foreach (var decl in decls)
{
if (decl.Declaration.Type.IsVar && VarIsAppropriate(decl))
{
var symbolInfo = (await model).GetSymbolInfo(decl.Declaration.Type);
}
}
return messages;
}
private static void ExcludeReturnedPassedAndAliasedLocalsAndPrivateFields(SyntaxNode typeDeclaration, SemanticModel semanticModel, ISet<ISymbol> excludedSymbols)
{
var identifiersAndSimpleMemberAccesses = typeDeclaration
.DescendantNodes()
.Where(n => n.IsKind(SyntaxKind.IdentifierName) || n.IsKind(SyntaxKind.SimpleMemberAccessExpression));
foreach (var identifierOrSimpleMemberAccess in identifiersAndSimpleMemberAccesses)
{
ExpressionSyntax expression;
if (identifierOrSimpleMemberAccess.IsKind(SyntaxKind.IdentifierName))
{
expression = (IdentifierNameSyntax)identifierOrSimpleMemberAccess;
}
else if (identifierOrSimpleMemberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
var memberAccess = (MemberAccessExpressionSyntax)identifierOrSimpleMemberAccess;
if (!memberAccess.Expression.IsKind(SyntaxKind.ThisExpression))
{
continue;
}
expression = memberAccess;
}
else
{
throw new NotSupportedException("Syntax node should be either an identifier or a simple member access expression");
}
if (!IsStandaloneExpression(expression))
{
continue;
}
var referencedSymbol = semanticModel.GetSymbolInfo(identifierOrSimpleMemberAccess).Symbol;
if (referencedSymbol != null && IsLocalOrPrivateField(referencedSymbol))
{
excludedSymbols.Add(referencedSymbol);
}
}
}
private static TypeDeclarationSyntax GetFirstTypeDeclaration(SyntaxNode root)
{
return root.DescendantNodes(descendIntoChildren: node => node.IsKind(SyntaxKind.CompilationUnit) || node.IsKind(SyntaxKind.NamespaceDeclaration))
.OfType<TypeDeclarationSyntax>()
.FirstOrDefault();
}
public IEnumerable<FieldDeclarationSyntax> FindFields(SyntaxNode node)
{
return node
.DescendantNodes(n => true)
.Where(n => n.IsKind(SyntaxKind.FieldDeclaration))
.Cast<FieldDeclarationSyntax>();
}
public ArgumentListSyntax FindArguments(SyntaxNode node)
{
return node
.DescendantNodes(n => true)
.Where(n => n.IsKind(SyntaxKind.ArgumentList))
.Cast<ArgumentListSyntax>()
.Single();
}
private static void TrackInitializedLocalsAndPrivateFields(SyntaxNode typeDeclaration, SemanticModel semanticModel, ISet<NodeAndSymbol> trackedNodesAndSymbols)
{
var localAndFieldDeclarations = typeDeclaration
.DescendantNodes()
.Where(n => n.IsKind(SyntaxKind.LocalDeclarationStatement) || n.IsKind(SyntaxKind.FieldDeclaration));
foreach (var localOrFieldDeclaration in localAndFieldDeclarations)
{
VariableDeclarationSyntax declaration;
if (localOrFieldDeclaration.IsKind(SyntaxKind.LocalDeclarationStatement))
{
declaration = ((LocalDeclarationStatementSyntax)localOrFieldDeclaration).Declaration;
}
else if (localOrFieldDeclaration.IsKind(SyntaxKind.FieldDeclaration))
{
var fieldDeclaration = (FieldDeclarationSyntax)localOrFieldDeclaration;
if (fieldDeclaration.Modifiers.Any() && !fieldDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PrivateKeyword)))
{
continue;
}
declaration = fieldDeclaration.Declaration;
}
else
{
throw new NotSupportedException("Syntax node should be either a local declaration or a field declaration");
}
foreach (var variableNode in declaration.Variables.Where(v => v.Initializer != null && IsInstantiation(v.Initializer.Value, semanticModel)))
{
trackedNodesAndSymbols.Add(new NodeAndSymbol { Node = variableNode, Symbol = semanticModel.GetDeclaredSymbol(variableNode) });
}
}
}
private static IReadOnlyList<UsingDirectiveSyntax> FindUsings( SyntaxNode node )
{
Contract.Requires( node != null );
Contract.Ensures( Contract.Result<IEnumerable<UsingDirectiveSyntax>>() != null );
return node.DescendantNodes().OfType<UsingDirectiveSyntax>().ToArray();
}
internal override bool ContainsLambda(SyntaxNode declaration)
{
return declaration.DescendantNodes().Any(LambdaUtilities.IsLambda);
}
private static void ExcludeDisposedAndClosedLocalsAndPrivateFields(SyntaxNode typeDeclaration, SemanticModel semanticModel, ISet<ISymbol> excludedSymbols)
{
var incovationsAndConditionalAccesses = typeDeclaration
.DescendantNodes()
.Where(n => n.IsKind(SyntaxKind.InvocationExpression) || n.IsKind(SyntaxKind.ConditionalAccessExpression));
foreach (var incovationOrConditionalAccess in incovationsAndConditionalAccesses)
{
SimpleNameSyntax name;
ExpressionSyntax expression;
if (incovationOrConditionalAccess.IsKind(SyntaxKind.InvocationExpression))
{
var invocation = (InvocationExpressionSyntax)incovationOrConditionalAccess;
var memberAccessNode = invocation.Expression as MemberAccessExpressionSyntax;
name = memberAccessNode?.Name;
expression = memberAccessNode?.Expression;
}
else if (incovationOrConditionalAccess.IsKind(SyntaxKind.ConditionalAccessExpression))
{
var conditionalAccess = (ConditionalAccessExpressionSyntax)incovationOrConditionalAccess;
var invocation = conditionalAccess.WhenNotNull as InvocationExpressionSyntax;
if (invocation == null)
{
continue;
}
var memberBindingNode = invocation.Expression as MemberBindingExpressionSyntax;
name = memberBindingNode?.Name;
expression = conditionalAccess.Expression;
}
else
{
throw new NotSupportedException("Syntax node should be either an invocation or a conditional access expression");
}
if (name == null || !DisposeMethods.Contains(name.Identifier.Text))
{
continue;
}
var referencedSymbol = semanticModel.GetSymbolInfo(expression).Symbol;
if (referencedSymbol != null && IsLocalOrPrivateField(referencedSymbol))
{
excludedSymbols.Add(referencedSymbol);
}
}
}
private static IReadOnlyList<ClassDeclarationSyntax> FindClasses( SyntaxNode node )
{
Contract.Requires( node != null );
Contract.Ensures( Contract.Result<IEnumerable<ClassDeclarationSyntax>>() != null );
var classes = from @class in node.DescendantNodes().OfType<ClassDeclarationSyntax>()
from name in @class.BaseList.DescendantNodes().OfType<IdentifierNameSyntax>()
where name.Identifier.Text == DbContext
select @class;
return classes.ToArray();
}
protected override bool CanAddImportForType(Diagnostic diagnostic, ref SyntaxNode node)
{
switch (diagnostic.Id)
{
case CS0103:
case CS0246:
case CS0305:
case CS0308:
case CS0122:
case CS0307:
case CS0616:
case CS1003:
case CS1580:
case CS1581:
break;
case CS1002:
//// only lookup errors inside ParenthesizedLambdaExpression e.g., () => { ... }
if (node.Ancestors().OfType<ParenthesizedLambdaExpressionSyntax>().Any())
{
if (node is SimpleNameSyntax)
{
break;
}
else if (node is BlockSyntax || node is MemberAccessExpressionSyntax || node is BinaryExpressionSyntax)
{
var last = node.DescendantNodes().OfType<SimpleNameSyntax>().LastOrDefault();
if (!TryFindStandaloneType(ref node))
{
node = node.DescendantNodes().OfType<SimpleNameSyntax>().FirstOrDefault();
}
else
{
node = last;
}
}
}
else
{
return false;
}
break;
case CS1574:
case CS1584:
var cref = node as QualifiedCrefSyntax;
if (cref != null)
{
node = cref.Container;
}
break;
default:
return false;
}
return TryFindStandaloneType(ref node);
}
private static void TrackAssignmentsToLocalsAndPrivateFields(SyntaxNode typeDeclaration, SemanticModel semanticModel, ISet<NodeAndSymbol> trackedNodesAndSymbols)
{
var simpleAssignments = typeDeclaration
.DescendantNodes()
.Where(n => n.IsKind(SyntaxKind.SimpleAssignmentExpression))
.Cast<AssignmentExpressionSyntax>();
foreach (var simpleAssignment in simpleAssignments)
{
if (simpleAssignment.Parent.IsKind(SyntaxKind.UsingStatement))
{
continue;
}
if (!IsInstantiation(simpleAssignment.Right, semanticModel))
{
continue;
}
var referencedSymbol = semanticModel.GetSymbolInfo(simpleAssignment.Left).Symbol;
if (referencedSymbol != null && IsLocalOrPrivateField(referencedSymbol))
{
trackedNodesAndSymbols.Add(new NodeAndSymbol { Node = simpleAssignment, Symbol = referencedSymbol });
}
}
}
private GenericNameSyntax FindListNode(SyntaxNode node)
{
return node.DescendantNodes().Where(f => f is GenericNameSyntax && IsList((GenericNameSyntax)f))
.OfType<GenericNameSyntax>()
.FirstOrDefault();
}
