protected override bool TryInitializeState(
Document document, SemanticModel model, SyntaxNode node, CancellationToken cancellationToken,
out INamedTypeSymbol classType, out INamedTypeSymbol abstractClassType)
{
var baseClassNode = node as TypeSyntax;
if (baseClassNode != null && baseClassNode.Parent is BaseTypeSyntax &&
baseClassNode.Parent.IsParentKind(SyntaxKind.BaseList) &&
((BaseTypeSyntax)baseClassNode.Parent).Type == baseClassNode)
{
if (baseClassNode.Parent.Parent.IsParentKind(SyntaxKind.ClassDeclaration))
{
abstractClassType = model.GetTypeInfo(baseClassNode, cancellationToken).Type as INamedTypeSymbol;
cancellationToken.ThrowIfCancellationRequested();
if (abstractClassType.IsAbstractClass())
{
var classDecl = baseClassNode.Parent.Parent.Parent as ClassDeclarationSyntax;
classType = model.GetDeclaredSymbol(classDecl, cancellationToken) as INamedTypeSymbol;
return classType != null && abstractClassType != null;
}
}
}
classType = null;
abstractClassType = null;
return false;
}
internal static IEnumerable<ISymbol> GetDeclaredSymbols(SemanticModel semanticModel, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken)
{
if (memberDeclaration is FieldDeclarationSyntax)
{
return ((FieldDeclarationSyntax)memberDeclaration).Declaration.Variables.Select(
v => semanticModel.GetDeclaredSymbol(v, cancellationToken));
}
return SpecializedCollections.SingletonEnumerable(
semanticModel.GetDeclaredSymbol(memberDeclaration, cancellationToken));
}
/// <summary>
/// Détermine si le inheritDoc du symbole méthode est présent et correct.
/// </summary>
/// <param name="racine">Le nœud racine de l'arbre syntaxtique courant.</param>
/// <param name="modèleSémantique">Le modèle sémantique lié.</param>
/// <param name="méthode">La méthode concernée.</param>
/// <returns>La ligne inheritDoc correcte dans le cas où l'actuelle est manquante/incorrecte, sinon null.</returns>
public static string InheritDocEstCorrect(SyntaxNode racine, SemanticModel modèleSémantique, MethodDeclarationSyntax méthode)
{
var classe = méthode?.Parent as ClassDeclarationSyntax;
// Si on est bien dans une méthode de classe.
if (méthode != null && classe != null)
{
// On récupère la version sémantique de la méthode pour identifier ses paramètres.
var méthodeSémantique = modèleSémantique.GetDeclaredSymbol(méthode);
// On liste toutes les méthodes des interfaces de la classe puis on cherche l'unique méthode avec la même signature.
var méthodeCorrespondantes = modèleSémantique.GetDeclaredSymbol(classe).Interfaces
.SelectMany(contrat => contrat.GetMembers())
.Where(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text
&& ((méthodeInterface as IMethodSymbol)?.Parameters.SequenceEqual(méthodeSémantique.Parameters, (p1, p2) => p1.Name == p2.Name) ?? false));
var méthodeCorrespondante = (méthodeCorrespondantes.Count() == 1 ? méthodeCorrespondantes.Single() : null) as IMethodSymbol;
// S'il y a bien une méthode correspondante, on continue.
if (méthodeCorrespondante != null)
{
// On récupère le nombre de méthode du même nom dans l'interface pour savoir s'il faut spécifier les paramètres ou non.
var nombreMéthodesSurchargées = (méthodeCorrespondante.ContainingSymbol as INamedTypeSymbol).GetMembers()
.Count(méthodeInterface => méthodeInterface.Name == méthode.Identifier.Text);
#pragma warning disable SA1013, SA1513
// On génère la ligne de documentation.
var inheritDoc = $@"/// <inheritdoc cref=""{
RécupérerNomType(méthode, méthodeCorrespondante, modèleSémantique)
}.{
RécupérerNomMéthode(méthode, méthodeCorrespondante)
+ RécupérerParamètres(méthode, méthodeCorrespondante, modèleSémantique, nombreMéthodesSurchargées)
}"" />";
#pragma warning restore SA1013, SA1513
// On récupère la documentation actuelle de la classe.
var documentationActuelle = méthode.GetLeadingTrivia().ToString().Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty);
// On la compare avec la ligne existante de façon bien crade, parce qu'en vrai elle n'est pas générée correctement.
// Désolé. J'ai vraiment essayé de faire proprement mais la génération propre de commentaires XML est odieuse.
// Si la ligne est différente et ne contient pas le mot "summary", on retourne la ligne de commentaire attendue.
if (!inheritDoc.Replace("\n", string.Empty).Replace("\r", string.Empty).Replace(" ", string.Empty)
.Equals(documentationActuelle) && !documentationActuelle.Contains("summary"))
return inheritDoc;
}
}
// Sinon on renvoie null, pour affirmer au diagnostic que tout va bien.
return null;
}
protected sealed override IEnumerable<Diagnostic> GetDiagnosticsForNode(SyntaxNode node, SemanticModel model)
{
var typeSymbol = model.GetDeclaredSymbol(node);
var namedType = typeSymbol as INamedTypeSymbol;
// static holder types are not already static/sealed and must be public or protected
if (namedType != null && !namedType.IsStatic && !namedType.IsSealed
&& (namedType.DeclaredAccessibility == Accessibility.Public || namedType.DeclaredAccessibility == Accessibility.Protected))
{
// only get the explicitly declared members
var allMembers = namedType.GetMembers().Where(member => !member.IsImplicitlyDeclared);
if (!allMembers.Any())
{
return null;
}
// to be a static holder type, all members must be static and not operator overloads
if (allMembers.All(member => member.IsStatic && !IsUserdefinedOperator(member)))
{
var diagnostic = typeSymbol.CreateDiagnostic(Rule, string.Format(FxCopRulesResources.TypeIsStaticHolderButNotSealed, namedType.Name));
return SpecializedCollections.SingletonEnumerable(diagnostic);
}
}
return null;
}
internal static ImmutableArray<TypeToRemove> GetTypesToRemove(
this SyntaxNode @this, SemanticModel model,
string documentFileNameWithoutExtension)
{
var typesToRemove = new List<TypeToRemove>();
TypeDeclarationSyntax typeToPreserve = null;
var typeNodes = @this.DescendantNodes(_ => true)
.OfType<TypeDeclarationSyntax>();
foreach(var typeNode in typeNodes)
{
var type = model.GetDeclaredSymbol(typeNode) as ITypeSymbol;
if(type.ContainingType == null)
{
if(type.Name != documentFileNameWithoutExtension)
{
typesToRemove.Add(new TypeToRemove(
typeNode, type));
}
else
{
typeToPreserve = typeNode;
}
}
}
return typesToRemove.ToImmutableArray();
}
protected IEnumerable<CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, ParameterSyntax node)
{
if (!node.Identifier.Span.Contains(span))
yield break;
var parameter = node;
var bodyStatement = parameter.Parent.Parent.ChildNodes().OfType<BlockSyntax>().FirstOrDefault();
if (bodyStatement == null)
yield break;
var parameterSymbol = semanticModel.GetDeclaredSymbol(node);
var type = parameterSymbol.Type;
if (type == null || type.IsValueType || HasNotNullContract(semanticModel, parameterSymbol, bodyStatement))
yield break;
yield return CreateAction(
node.Identifier.Span
, t2 => {
var newBody = bodyStatement.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { CreateContractRequiresCall(node.Identifier.ToString()) }.Concat(bodyStatement.Statements)));
var newRoot = (CompilationUnitSyntax)root.ReplaceNode((SyntaxNode)bodyStatement, newBody);
if (UsingStatementNotPresent(newRoot)) newRoot = AddUsingStatement(node, newRoot);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
, "Add contract requiring parameter must not be null"
);
}
protected override async Task<EvaluationResult> EvaluateImpl(SyntaxNode node, SemanticModel semanticModel, Solution solution)
{
var symbol = (ITypeSymbol)semanticModel.GetDeclaredSymbol(node);
var efferent = GetReferencedTypes(node, symbol, semanticModel).AsArray();
var awaitable = SymbolFinder.FindCallersAsync(symbol, solution, CancellationToken.None).ConfigureAwait(false);
var callers = (await awaitable).AsArray();
var testCallers = callers
.Where(c => c.CallingSymbol.GetAttributes()
.Any(x => x.AttributeClass.Name.IsKnownTestAttribute()))
.AsArray();
var afferent = callers.Except(testCallers)
.Select(x => x.CallingSymbol.ContainingType)
.DistinctBy(s => s.ToDisplayString())
.AsArray();
var efferentLength = (double)efferent.Length;
var stability = efferentLength / (efferentLength + afferent.Length);
if (stability >= 0.8)
{
return new EvaluationResult
{
ImpactLevel = ImpactLevel.Project,
Quality = CodeQuality.NeedsReview,
QualityAttribute = QualityAttribute.CodeQuality | QualityAttribute.Conformance,
Snippet = node.ToFullString()
};
}
return null;
}
internal static bool HasFlagsAttribute(SyntaxNode node, SemanticModel semanticModel)
{
var symbol = semanticModel.GetDeclaredSymbol(node);
return symbol != null &&
symbol.GetAttributes().Any(attribute => attribute.AttributeClass.Is(KnownType.System_FlagsAttribute));
}
private static ISymbol GetDeclaredSymbol(SemanticModel model, SyntaxNode node, bool getSymbol, CancellationToken cancellationToken)
{
if (!getSymbol)
{
return null;
}
var declaredSymbol = model.GetDeclaredSymbol(node, cancellationToken);
// For namespace declarations, GetDeclaredSymbol returns a compilation scoped namespace symbol,
// which includes declarations across the compilation, including those in referenced assemblies.
// However, we are only interested in the namespace symbol scoped to the compilation's source assembly.
var namespaceSymbol = declaredSymbol as INamespaceSymbol;
if (namespaceSymbol != null && namespaceSymbol.ConstituentNamespaces.Length > 1)
{
var assemblyToScope = model.Compilation.Assembly;
var assemblyScopedNamespaceSymbol = namespaceSymbol.ConstituentNamespaces.FirstOrDefault(ns => ns.ContainingAssembly == assemblyToScope);
if (assemblyScopedNamespaceSymbol != null)
{
Debug.Assert(assemblyScopedNamespaceSymbol.ConstituentNamespaces.Length == 1);
declaredSymbol = assemblyScopedNamespaceSymbol;
}
}
return declaredSymbol;
}
/// <summary>
/// This is jus a test to check the ability to preprocess the AST
/// </summary>
/// <param name="methodNode"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
public static IMethodSymbol SimplifyASTForMethod(ref SyntaxNode methodNode, ref SemanticModel semanticModel)
{
var oldMethod = semanticModel.GetDeclaredSymbol(methodNode) as IMethodSymbol;
var newMethodNode = MethodSimpifier.Test(methodNode);
var annotation = new SyntaxAnnotation("Hi");
newMethodNode = newMethodNode.WithAdditionalAnnotations(annotation);
var root = methodNode.SyntaxTree.GetRoot();
var newRoot = root.ReplaceNode(methodNode, newMethodNode);
var oldCompilation = semanticModel.Compilation;
var newCompilation = oldCompilation.ReplaceSyntaxTree(root.SyntaxTree, newRoot.SyntaxTree);
var newSemanticModel = newCompilation.GetSemanticModel(newRoot.SyntaxTree);
var recoveredMethodNode = newRoot.GetAnnotatedNodes(annotation).Single();
var method = newSemanticModel.GetDeclaredSymbol(recoveredMethodNode) as IMethodSymbol;
methodNode = recoveredMethodNode;
semanticModel = newSemanticModel;
return method;
}
internal static DeclarationInfo GetDeclarationInfo(SemanticModel model, SyntaxNode node, bool getSymbol, IEnumerable<SyntaxNode> executableCodeBlocks, CancellationToken cancellationToken)
{
var declaredSymbol = getSymbol ? model.GetDeclaredSymbol(node, cancellationToken) : null;
var codeBlocks = executableCodeBlocks == null ?
ImmutableArray<SyntaxNode>.Empty :
executableCodeBlocks.Where(c => c != null).AsImmutableOrEmpty();
return new DeclarationInfo(node, codeBlocks, declaredSymbol);
}
internal override Task<Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, Diagnostic diagnostic, CancellationToken cancellationToken)
{
var classSymbol = (INamedTypeSymbol)model.GetDeclaredSymbol(nodeToFix, cancellationToken);
var instanceConstructors = classSymbol.InstanceConstructors.Where(t => t.DeclaredAccessibility == Accessibility.Public).Select(t => GetDeclaration(t)).Where(d => d != null).ToList();
var generator = SyntaxGenerator.GetGenerator(document);
var newRoot = root.ReplaceNodes(instanceConstructors, (original, rewritten) => generator.WithAccessibility(original, Accessibility.Protected));
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
protected override IEnumerable<ISymbol> GetSymbols(SyntaxNode node, SemanticModel semanticModel)
{
var declaration = (VariableDeclarationSyntax)node;
var symbols = declaration.Variables.Select(x => semanticModel.GetDeclaredSymbol(x)).AsArray();
return symbols;
}
static bool AreVariablesOnlyWrittenInsideDeclaration(LocalDeclarationStatementSyntax declaration, SemanticModel semanticModel)
{
var dfa = semanticModel.AnalyzeDataFlow(declaration);
var symbols = from variable in declaration.Declaration.Variables
select semanticModel.GetDeclaredSymbol(variable);
var result = !symbols.Any(s => dfa.WrittenOutside.Contains(s));
return result;
}
/// <summary>
/// Returns true if the given expression flows in the target.
/// </summary>
/// <param name="variable">Variable</param>
/// <param name="target">Target</param>
/// <param name="syntaxNode">SyntaxNode</param>
/// <param name="cfgNode">ControlFlowGraphNode</param>
/// <param name="targetSyntaxNode">Target syntaxNode</param>
/// <param name="targetCfgNode">Target controlFlowGraphNode</param>
/// <param name="model">SemanticModel</param>
/// <returns>Boolean</returns>
internal static bool FlowsIntoTarget(VariableDeclaratorSyntax variable, ISymbol target,
SyntaxNode syntaxNode, ControlFlowGraphNode cfgNode, SyntaxNode targetSyntaxNode,
ControlFlowGraphNode targetCfgNode, SemanticModel model)
{
ISymbol reference = model.GetDeclaredSymbol(variable);
return DataFlowAnalysis.FlowsIntoTarget(reference, target, syntaxNode,
cfgNode, targetSyntaxNode, targetCfgNode);
}
public static ISymbol GetDeclaredOrReferencedSymbol(this SyntaxNode node, SemanticModel model)
{
if (node == null)
{
return null;
}
return model.GetDeclaredSymbol(node) ?? model.GetSymbolInfo(node).Symbol;
}
private static async Task<Document> Fix(CodeFixContext context, SyntaxNode root, SyntaxGenerator generator, SemanticModel semanticModel, CancellationToken cancellationToken)
{
SyntaxNode node = root.FindNode(context.Span);
Diagnostic diagnostic = context.Diagnostics.First();
switch (diagnostic.Properties[OperatorOverloadsHaveNamedAlternatesAnalyzer.DiagnosticKindText])
{
case OperatorOverloadsHaveNamedAlternatesAnalyzer.AddAlternateText:
SyntaxNode methodDeclaration = generator.GetDeclaration(node, DeclarationKind.Operator) ?? generator.GetDeclaration(node, DeclarationKind.ConversionOperator);
var operatorOverloadSymbol = (IMethodSymbol)semanticModel.GetDeclaredSymbol(methodDeclaration, cancellationToken);
INamedTypeSymbol typeSymbol = operatorOverloadSymbol.ContainingType;
// For C# the following `typeDeclarationSyntax` and `typeDeclaration` nodes are identical, but for VB they're different so in
// an effort to keep this as language-agnostic as possible, the heavy-handed approach is used.
SyntaxNode typeDeclarationSyntax = typeSymbol.DeclaringSyntaxReferences.First().GetSyntax(cancellationToken);
SyntaxNode typeDeclaration = generator.GetDeclaration(typeDeclarationSyntax, DeclarationKind.Class);
SyntaxNode addedMember;
ImmutableArray<SyntaxNode> bodyStatements = ImmutableArray.Create(
generator.ThrowStatement(generator.ObjectCreationExpression(semanticModel.Compilation.GetTypeByMetadataName("System.NotImplementedException"))));
if (OperatorOverloadsHaveNamedAlternatesAnalyzer.IsPropertyExpected(operatorOverloadSymbol.Name))
{
// add a property
addedMember = generator.PropertyDeclaration(
name: OperatorOverloadsHaveNamedAlternatesAnalyzer.IsTrueText,
type: generator.TypeExpression(SpecialType.System_Boolean),
accessibility: Accessibility.Public,
modifiers: DeclarationModifiers.ReadOnly,
getAccessorStatements: bodyStatements);
}
else
{
// add a method
ExpectedMethodSignature expectedSignature = GetExpectedMethodSignature(operatorOverloadSymbol, semanticModel.Compilation);
addedMember = generator.MethodDeclaration(
name: expectedSignature.Name,
parameters: expectedSignature.Parameters.Select(p => generator.ParameterDeclaration(p.Item1, generator.TypeExpression(p.Item2))),
returnType: generator.TypeExpression(expectedSignature.ReturnType),
accessibility: Accessibility.Public,
modifiers: expectedSignature.IsStatic ? DeclarationModifiers.Static : DeclarationModifiers.None,
statements: bodyStatements);
}
SyntaxNode newTypeDeclaration = generator.AddMembers(typeDeclaration, addedMember);
return context.Document.WithSyntaxRoot(root.ReplaceNode(typeDeclaration, newTypeDeclaration));
case OperatorOverloadsHaveNamedAlternatesAnalyzer.FixVisibilityText:
SyntaxNode badVisibilityNode = generator.GetDeclaration(node, DeclarationKind.Method) ?? generator.GetDeclaration(node, DeclarationKind.Property);
ISymbol badVisibilitySymbol = semanticModel.GetDeclaredSymbol(badVisibilityNode, cancellationToken);
SymbolEditor symbolEditor = SymbolEditor.Create(context.Document);
ISymbol newSymbol = await symbolEditor.EditOneDeclarationAsync(badVisibilitySymbol,
(documentEditor, syntaxNode) => documentEditor.SetAccessibility(badVisibilityNode, Accessibility.Public)).ConfigureAwait(false);
Document newDocument = symbolEditor.GetChangedDocuments().Single();
SyntaxNode newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
return context.Document.WithSyntaxRoot(newRoot);
default:
return context.Document;
}
}
private static SyntaxNode RemoveFlagsAttribute(SyntaxGenerator generator, SemanticModel model, SyntaxNode enumTypeSyntax, INamedTypeSymbol flagsAttributeType, CancellationToken cancellationToken)
{
var enumType = model.GetDeclaredSymbol(enumTypeSyntax, cancellationToken) as INamedTypeSymbol;
Debug.Assert(enumType != null);
AttributeData flagsAttribute = enumType.GetAttributes().First(a => a.AttributeClass == flagsAttributeType);
SyntaxNode attributeNode = flagsAttribute.ApplicationSyntaxReference.GetSyntax(cancellationToken);
return generator.RemoveNode(enumTypeSyntax, attributeNode);
}
public static IEnumerable<MemberDeclarationSyntax> GetMembersFromAllParts(this ClassDeclarationSyntax type, SemanticModel model)
{
var typeSymbol = model.GetDeclaredSymbol(type);
if (typeSymbol.IsErrorType())
return null;
var allTypeDeclarations = typeSymbol.DeclaringSyntaxReferences.Select(sr => sr.GetSyntax()).OfType<ClassDeclarationSyntax>();
if (allTypeDeclarations.Any())
return allTypeDeclarations.SelectMany(t => t.Members);
return null;
}
private static void CaptureCandidateFields(FieldDeclarationSyntax field, SemanticModel semanticModel, List<FieldCandidate> candidateFields)
{
if (!CanBecameReadOnlyField(field)) return;
var variables = field.Declaration.Variables;
var currentAnalysisCandidateFields = variables.Select(s => new FieldCandidate { Variable = s, FieldSymbol = semanticModel.GetDeclaredSymbol(s) as IFieldSymbol })
.Where(p => p.FieldSymbol != null && p.FieldSymbol.ContainingType != null);
if (!currentAnalysisCandidateFields.Any()) return;
candidateFields.AddRange(currentAnalysisCandidateFields);
}
private bool IsInternal(SyntaxNode invocation, SemanticModel model, out string nameSpace)
{
var containingType = _documentWalker.GetContainingNodeOfType<TypeDeclarationSyntax>(invocation);
var typeSymbol = model.GetDeclaredSymbol(containingType) as INamedTypeSymbol;
if (typeSymbol == null) throw new NoNamedTypeException(containingType.ToString());
nameSpace = typeSymbol.ContainingNamespace.Name;
var invocationSymbol = model.GetSymbolInfo(invocation).Symbol;
if (invocationSymbol == null) return true; // No Symbol -> Anonymous Method -> is Internal
var members = containingType.Members;
return _documentWalker.IsSymbolInvocationOfNodes(members, invocationSymbol, model);
}
internal static NavTaskAnnotation ReadNavTaskAnnotation(SemanticModel semanticModel, ClassDeclarationSyntax classDeclarationSyntax) {
if(semanticModel == null || classDeclarationSyntax == null) {
return null;
}
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclarationSyntax);
var navTaskInfo = ReadNavTaskAnnotation(classDeclarationSyntax, classSymbol);
return navTaskInfo;
}
internal static bool IsEventHandler(MethodStatementSyntax declaration, SemanticModel semanticModel)
{
if (declaration.HandlesClause != null)
{
return true;
}
var symbol = semanticModel.GetDeclaredSymbol(declaration);
return symbol != null &&
symbol.IsProbablyEventHandler();
}
private ReferenceRewriter(
SemanticModel semanticModel,
VariableDeclaratorSyntax variableDeclarator,
ExpressionSyntax expressionToInline,
CancellationToken cancellationToken)
{
_semanticModel = semanticModel;
_localSymbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(variableDeclarator, cancellationToken);
_variableDeclarator = variableDeclarator;
_expressionToInline = expressionToInline;
_cancellationToken = cancellationToken;
}
public static SyntaxNode MockClass(SyntaxTree tree, SemanticModel semanticModel, ClassDeclarationSyntax classNode)
{
SyntaxNode root = tree.GetRoot();
Console.WriteLine("Class name: " + classNode.Identifier.Text);
SyntaxList<MemberDeclarationSyntax> members = new SyntaxList<MemberDeclarationSyntax>();
List<string> usedNames = new List<string>();
foreach (var member in classNode.Members)
{
if (member is MethodDeclarationSyntax)
{
var method = (MethodDeclarationSyntax)member;
Console.WriteLine("\tMethod name: " + method.Identifier.Text);
IMethodSymbol methodSemanticData = semanticModel.GetDeclaredSymbol(method) as IMethodSymbol;
members = members.Add(CreateMethodDelegate(method, methodSemanticData, usedNames));
members = members.Add(CreateMethodBody(method, methodSemanticData, usedNames));
}
else if (member is PropertyDeclarationSyntax)
{
var property = (PropertyDeclarationSyntax)member;
Console.WriteLine("\tProperty name: " + property.Identifier.Text);
IPropertySymbol propertySemanticData = semanticModel.GetDeclaredSymbol(property) as IPropertySymbol;
members = members.Add(GenerateProperty(property, propertySemanticData, usedNames));
}
else
{
members = members.Add(member);
}
}
SyntaxToken classIdentifier = SF.IdentifierName(classNode.Identifier.Text + "Mock").GetFirstToken();
var classDeclaration = SF.ClassDeclaration(classNode.AttributeLists, classNode.Modifiers, classIdentifier, classNode.TypeParameterList, classNode.BaseList, classNode.ConstraintClauses, members);
return SF.NamespaceDeclaration(SF.IdentifierName("TestNamespace")).AddUsings(SF.UsingDirective(SF.IdentifierName("System"))).AddMembers(classDeclaration);
}
private static bool IsMethodUsed(MethodDeclarationSyntax methodTarget, SemanticModel semanticModel)
{
var typeDeclaration = methodTarget.Parent as TypeDeclarationSyntax;
if (typeDeclaration == null) return true;
if (!typeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword))
return IsMethodUsed(methodTarget, typeDeclaration);
var symbol = semanticModel.GetDeclaredSymbol(typeDeclaration);
return
symbol == null ||
symbol.DeclaringSyntaxReferences.Any(reference => IsMethodUsed(methodTarget, reference.GetSyntax()));
}
protected override async Task<EvaluationResult> EvaluateImpl(SyntaxNode node, SemanticModel semanticModel, Solution solution)
{
var symbol = semanticModel.GetDeclaredSymbol(node);
var callers = await solution.FindReferences(symbol).ConfigureAwait(false);
if (!callers.Locations.Any(x => IsNotAssignment(x.Location)))
{
return new EvaluationResult
{
Snippet = node.ToFullString()
};
}
return null;
}
private static ClassNode CreateClassNode(SemanticModel model, ClassDeclarationSyntax c)
{
var declaredSymbol = model.GetDeclaredSymbol(c);
var subnodes = c.DescendantNodes();
var symbols = subnodes.Select(node => model.GetSymbolInfo(node).Symbol).ToList();
var dependencies = symbols.OfType<INamedTypeSymbol>();
var nrOfMethods = subnodes.OfType<MethodDeclarationSyntax>().Count();
IEnumerable<TypeSyntax> basetypes = new List<TypeSyntax>();
if (c.BaseList != null && c.BaseList.Types.Any())
basetypes = c.BaseList.Types.Select(x => x.Type);
return new ClassNode(declaredSymbol, basetypes, nrOfMethods) {SymbolDependencies = dependencies};
}
public override ITypeSymbol GetClassDeclarationTypeSymbol(SyntaxNode node, SemanticModel semanticModel)
{
if (node == null)
{
return null;
}
SyntaxKind kind = node.Kind();
if (kind == SyntaxKind.ClassDeclaration)
{
return semanticModel.GetDeclaredSymbol((ClassDeclarationSyntax)node);
}
return null;
}
private static ITypeSymbol ResolveContainingType(SyntaxNode node, SemanticModel model)
{
if (node == null)
{
return null;
}
var parent = node.Parent;
if (parent is BaseTypeDeclarationSyntax)
{
var symbolInfo = model.GetDeclaredSymbol(parent);
return symbolInfo as ITypeSymbol;
}
return ResolveContainingType(parent, model);
}
/// <summary>
/// Returns the semantic declared symbol of the provided syntax node as the provided symbol type
/// </summary>
/// <param name="syntaxNode">The syntax node</param>
/// <param name="model">The syntax semantic model</param>
/// <returns>The symbol of the provided syntax node</returns>
public static ISymbol GetDeclaredSymbol(this SyntaxNode syntaxNode, SemanticModel model)
{
return(model.GetDeclaredSymbol(syntaxNode));
}
/// <summary>
/// Returns the semantic symbol of the provided syntax node, or the declared symbol if the previous cast was invalid
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
/// <returns>The symbol or declared symbol of the provided syntax node</returns>
public static ISymbol GetSymbolOrDeclared(this SyntaxNode syntaxNode, SemanticModel semanticModel)
{
return(semanticModel.GetSymbolInfo(syntaxNode).Symbol ?? semanticModel.GetDeclaredSymbol(syntaxNode));
}
/// <summary>
/// Returns the semantic declared symbol of the provided syntax node as the provided symbol type
/// </summary>
/// <param name="syntaxNode">The syntax node</param>
/// <param name="model">The syntax analysis context</param>
/// <returns>The symbol of the provided syntax node</returns>
public static TSymbolType GetDeclaredSymbolAs <TSymbolType>(this SyntaxNode syntaxNode, SemanticModel model) where TSymbolType : class, ISymbol
{
return(model.GetDeclaredSymbol(syntaxNode) as TSymbolType);
}