private async Task<Document> ApplyReplacement(Document document, IdentifierNameSyntax node, CancellationToken cancellationToken, string replaceWithName, string namespaceUsed) {
            IdentifierNameSyntax newNode = SyntaxFactory.IdentifierName(replaceWithName)
                .WithLeadingTrivia(node.GetLeadingTrivia())
                .WithTrailingTrivia(node.GetTrailingTrivia());
            var oldNode = node.Parent.Kind() == SyntaxKind.SimpleMemberAccessExpression ? node.Parent : node;

            document = await this.ReplaceNodeInDocumentAsync(document, cancellationToken, oldNode, newNode);
            return await this.CheckNamespaceUsageAsync(document, cancellationToken, namespaceUsed);
        }
        private async Task<Solution> UseTypeExplicit(Document document, IdentifierNameSyntax identifierName, TypeInfo typeInfo, CancellationToken cancellationToken)
        {
            var root = await document.GetSyntaxRootAsync();
            var newIdentifierName =
                SyntaxFactory.ParseTypeName(typeInfo.ConvertedType.ToString())
                    .WithAdditionalAnnotations(Simplifier.Annotation)
                    .WithLeadingTrivia(identifierName.GetLeadingTrivia())
                    .WithTrailingTrivia(identifierName.GetTrailingTrivia());

            var newDocument = document.WithSyntaxRoot(root.ReplaceNode(identifierName, newIdentifierName));
            return newDocument.Project.Solution;
        }
            public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
            {
                if (this.semanticModel == null)
                {
                    this.semanticModel = this.document.GetSemanticModelAsync(this.cancellationToken).Result;
                }

                var symbolInfo = this.semanticModel.GetSymbolInfo(node, this.cancellationToken);

                if (symbolInfo.Symbol == null)
                {
                    return node;
                }
                    
                if ((symbolInfo.Symbol.Kind == SymbolKind.Field ||
                    symbolInfo.Symbol.Kind == SymbolKind.Property ||
                    symbolInfo.Symbol.Kind == SymbolKind.Method ||
                    symbolInfo.Symbol.Kind == SymbolKind.Event) &&
                    symbolInfo.Symbol.CanBeReferencedByName &&
                    !symbolInfo.Symbol.IsStatic &&
                    !HasThisAccess(node) && 
                    CanAnnotateProperty(node))
                {
                    this.addedAnnotations = true;
                    var trivia = node.GetLeadingTrivia();

                    var memberAccess = SyntaxFactory.MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        SyntaxFactory.ThisExpression(),
                        node.WithoutLeadingTrivia());

                    return memberAccess.WithLeadingTrivia(trivia);
                }

                return base.VisitIdentifierName(node);
            }