private static SyntaxNode RemoveCall(SyntaxNode root,
     InvocationExpressionSyntax castInvocation, MemberAccessExpressionSyntax memberAccess)
 {
     return castInvocation != null
         ? RemoveExtensionMethodCall(root, castInvocation)
         : RemoveStaticMemberCall(root, memberAccess);
 }

        public bool ShouldUseTap(MemberAccessExpressionSyntax memberAccessExpression)
        {
            if (memberAccessExpression.IsWrappedInAwaitExpression() || memberAccessExpression.IsWrappedInLock())
            {
                return false;
            }

            var identifierName = memberAccessExpression.Name as IdentifierNameSyntax;
            if (identifierName?.Identifier.ValueText != nameof(Task<int>.Result))
            {
                return false;
            }

            var lambdaExpression = memberAccessExpression.FirstAncestorOrSelf<LambdaExpressionSyntax>();
            if (lambdaExpression == null)
            {
                var methodDeclaration = memberAccessExpression.FirstAncestorOrSelf<MethodDeclarationSyntax>();
                if (methodDeclaration == null || methodDeclaration.HasOutOrRefParameters())
                {
                    return false;
                }
            }

            var symbol = FindSymbol(memberAccessExpression.Expression);
            if (symbol == null)
            {
                return false;
            }
            var taskSymbol = semanticModel.Compilation.GetTypeByMetadataName(typeof(Task).FullName);
            var taskOfTSymbol = semanticModel.Compilation.GetTypeByMetadataName(typeof(Task).FullName + "`1");

            return symbol.IsGenericType ?
                symbol.ConstructedFrom.Equals(taskOfTSymbol) :
                symbol.Equals(taskSymbol);
        }

 public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
 {
     base.VisitMemberAccessExpression(node);
     if (node.Parent is MemberAccessExpressionSyntax || node.Parent is InvocationExpressionSyntax)
         return;
     if (node.Expression.IsKind(SyntaxKind.ThisExpression))
         Check(node);
 }

        static SyntaxNode ToStaticMethodInvocation(SemanticModel model, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess, SymbolInfo invocationRR)
        {
            var newArgumentList = invocation.ArgumentList.Arguments.ToList();
            newArgumentList.Insert(0, SyntaxFactory.Argument(memberAccess.Expression.WithoutLeadingTrivia()));

            var newTarget = memberAccess.WithExpression(SyntaxFactory.ParseTypeName(invocationRR.Symbol.ContainingType.ToMinimalDisplayString(model, memberAccess.SpanStart)));
            return SyntaxFactory.InvocationExpression(newTarget, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(newArgumentList)));
        }

        private static bool IsInvocationOfApply(MemberAccessExpressionSyntax memberAccessSyntax, string bindingSetIdentifierString)
        {
            var identifierName = memberAccessSyntax.Expression as IdentifierNameSyntax;

            if (identifierName?.Identifier.ValueText != bindingSetIdentifierString) return false;

            return memberAccessSyntax.Name.Identifier.ValueText == "Apply";
        }

        private static bool IsInvocationOfBind(MemberAccessExpressionSyntax memberAccessSyntax, string bindingSetIdentifierString)
        {
            var identifierName = GetIdentifierRecursive(memberAccessSyntax);

            if (identifierName?.Identifier.ValueText != bindingSetIdentifierString) return false;

            return memberAccessSyntax.Name.Identifier.ValueText == "Bind";
        }

        public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
        {
            // Dong Xie: node.Name.GetText() 
            if (node.Name.GetText().ToString() != PublishKeyword) return;

            PublicationCalls.Add(node);
            Publications.Add(node.Ancestors().OfType<InvocationExpressionSyntax>().Last());
        }

 public void FixStringToCharInvocation(MemberAccessExpressionSyntax toCharArrayInvocation, Diagnostic diagnostic, CodeFixContext context, SyntaxNode root)
 {
     context.RegisterCodeFix(CodeActionFactory.Create(toCharArrayInvocation.Span, diagnostic.Severity, "Remove redundant 'string.ToCharArray()' call",
     token =>
     {
         var newRoot = root.ReplaceNode(toCharArrayInvocation.Parent, toCharArrayInvocation.Expression
             .WithAdditionalAnnotations(Formatter.Annotation));
         return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
     }), diagnostic);
 }

        private bool IsPrivateField(MemberAccessExpressionSyntax memberSyntax, SemanticModel model, CancellationToken token)
        {
            var symbolInfo = model.GetSymbolInfo(memberSyntax, token);
            if (symbolInfo.Symbol != null && symbolInfo.Symbol.Kind == SymbolKind.Field)
            {
                var field = (IFieldSymbol)symbolInfo.Symbol;
                return field.DeclaredAccessibility == Accessibility.Private;
            }

            return false;
        }

        private async Task<Document> InsertAsyncCall(Document document, MemberAccessExpressionSyntax memberAccess, CancellationToken cancellationToken)
        {
            var name = memberAccess.Name.Identifier.ValueText;
            ExpressionSyntax oldNode, newNode, newMemberAccess;
            switch (name)
            {
                case "WaitAny":
                    newMemberAccess = memberAccess.WithName((SimpleNameSyntax)SyntaxFactory.ParseName("WhenAny"));
                    break;
                case "WaitAll":
                    newMemberAccess = memberAccess.WithName((SimpleNameSyntax)SyntaxFactory.ParseName("WhenAny"));
                    break;
                case "Wait":
                    newMemberAccess = memberAccess.Expression;
                    break;
                case "Result":
                    newMemberAccess = memberAccess.Expression;
                    break;
                case "Sleep":
                    newMemberAccess = SyntaxFactory.ParseExpression("Task.Delay");
                    break;
                default:
                    newMemberAccess = memberAccess.WithName((SimpleNameSyntax)SyntaxFactory.ParseName(memberAccess.Name.Identifier.ValueText + "Async"));
                    break;
            }

            var invoc = memberAccess.Parent as InvocationExpressionSyntax;
            // WaitAny, WaitAll, Wait, Sleep, XyzAsync etc.
            if (invoc != null)
            {
                oldNode = invoc;
                newNode = name == "Wait" ? newMemberAccess : invoc.WithExpression(newMemberAccess);
            }
            // t.Result
            else
            {
                oldNode = memberAccess;
                newNode = newMemberAccess;
            }

            newNode = SyntaxFactory.AwaitExpression(newNode)
                .WithAdditionalAnnotations(Formatter.Annotation)
                .WithLeadingTrivia(memberAccess.GetLeadingTrivia())
                .WithTrailingTrivia(memberAccess.GetTrailingTrivia());

            if (oldNode.Parent.Kind() == SyntaxKind.SimpleMemberAccessExpression)
            {
                newNode = SyntaxFactory.ParenthesizedExpression(newNode);
            }

            var root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
            var newRoot = root.ReplaceNode(oldNode, newNode);
            return document.WithSyntaxRoot(newRoot);
        }

 static bool CouldBeAnAssert(MemberAccessExpressionSyntax memberAccess)
 {
     for (var i = 0; i < NUnitAssertMethods.All.Count; i++)
     {
         if (NUnitAssertMethods.All[i].CouldBeEqualto(memberAccess))
         {
             return true;
         }
     }
     return false;
 }

        public MemberAccessExpressionTranslation(MemberAccessExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
        {
            Expression = syntax.Expression.Get<ExpressionTranslation>(this);
            Name = syntax.Name.Get<SimpleNameTranslation>(this);

            var simpleName = Name as SimpleNameTranslation;

            if (simpleName != null)
            {
                simpleName.DetectApplyThis = false;
            }
        }

            public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
            {
                node = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node);
                var name = node.Name.Identifier.ValueText;
                if (node.Expression != null &&
                    node.Expression.Kind() == SyntaxKind.ThisExpression &&
                    IsPrivateField(node))
                {
                    _addedAnnotations = true;
                    return node.WithAdditionalAnnotations(Simplifier.Annotation);
                }

                return node;
            }

            private bool IsPrivateField(MemberAccessExpressionSyntax memberSyntax)
            {
                if (_semanticModel == null)
                {
                    _semanticModel = _document.GetSemanticModelAsync(_cancellationToken).Result;
                }

                var symbolInfo = _semanticModel.GetSymbolInfo(memberSyntax, _cancellationToken);
                if (symbolInfo.Symbol != null && symbolInfo.Symbol.Kind == SymbolKind.Field)
                {
                    var field = (IFieldSymbol)symbolInfo.Symbol;
                    return field.DeclaredAccessibility == Accessibility.Private;
                }

                return false;
            }

            public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
            {
                bool oldAlwaysSimplify = this.alwaysSimplify;
                if (!this.alwaysSimplify)
                {
                    this.alwaysSimplify = node.HasAnnotation(Simplifier.Annotation);
                }

                var result = SimplifyExpression(
                    node,
                    newNode: base.VisitMemberAccessExpression(node),
                    simplifier: SimplifyName);

                this.alwaysSimplify = oldAlwaysSimplify;

                return result;
            }

        /// <summary>
        /// Determines if a MemberAccessExpressionSyntax can be fixed by our codefix
        /// </summary>
        public static bool CanFix(MemberAccessExpressionSyntax memberAccessExpression)
        {
            // Verify if it is a call to one of the methods we can fix
            if (!MethodNamesToRefactor.Contains(memberAccessExpression.Name.ToString())) return false;

            // The parent should be an InvocationExpressionSyntax
            var defaultIfNullexpression = memberAccessExpression.Parent as InvocationExpressionSyntax;

            // There should be one argument, the lambda expression
            if (defaultIfNullexpression?.ArgumentList.Arguments.Count != 1) return false;

            var lambda = GetLambdaFromFirstArgument(defaultIfNullexpression);
            if (lambda == null) return false;

            // Check if the Lambas body starts with a AccessExpression of the parameter
            return GetLeftMostAccessExpression(lambda) != null;
        }

 private static CompilationUnitSyntax ImportNeededNamespace(CompilationUnitSyntax root, SemanticModel semanticModel, MemberAccessExpressionSyntax callerMethod)
 {
     var symbolInfo = semanticModel.GetSymbolInfo(callerMethod.Name);
     var methodSymbol = symbolInfo.Symbol as IMethodSymbol;
     if (methodSymbol == null) return root;
     var namespaceDisplayString = methodSymbol.ContainingNamespace.ToDisplayString();
     var hasNamespaceImported = root
         .DescendantNodes()
         .OfType<UsingDirectiveSyntax>()
         .Select(s => s.Name.ToString())
         .Any(n => n == namespaceDisplayString);
     if (!hasNamespaceImported)
     {
         var namespaceQualifiedName = methodSymbol.ContainingNamespace.ToNameSyntax();
         root = root.AddUsings(SyntaxFactory.UsingDirective(namespaceQualifiedName));
     }
     return root;
 }

        public static IMethodSymbol LookupMethodSymbol(this SemanticModel model, MemberAccessExpressionSyntax memberAccess)
        {
            if (model == null) throw new ArgumentNullException("model");
            if (memberAccess == null) throw new ArgumentNullException("memberAccess");

            var expression = memberAccess;

            Logger.Trace("Looking up symbol for: {0}", expression);

            var symbol = model.GetSymbolInfo(expression).Symbol;

            var methodSymbol = symbol as IMethodSymbol;
            if (methodSymbol != null)
            {
                NumMethodSymbolLookups++;
                return methodSymbol;
            }

            throw new MethodSymbolMissingException(memberAccess);
        }

        public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
        {
            SyntaxNode r_node = node;

            if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) && node.ToString() == "ById.OnLeft")
            {
                var p = node.HasParent<ArgumentSyntax, ArgumentListSyntax, InvocationExpressionSyntax, EqualsValueClauseSyntax, VariableDeclaratorSyntax>();
                if (p == null)
                {

                }
                else
                {
                    var byId = SyntaxFactory.ParseExpression("\"#" + p.Identifier.Text + "\"");
                    //var argById = SyntaxFactory.Argument(byId);
                    r_node = byId;
                }
            }

            return r_node;
        }

 public InitializeBodyInfo(InvocationExpressionSyntax invocationExpr = null, MemberAccessExpressionSyntax memberExpr = null)
 {
     InvocationExpr = invocationExpr;
     MemberExpr = memberExpr;
 }