public override void VisitIdentifierName(IdentifierNameSyntax node)
 {
     base.VisitIdentifierName(node);
     var symbol = nodeContext.SemanticModel.GetSymbolInfo(node).Symbol;
     if (symbol.IsKind(SymbolKind.TypeParameter))
         UsedTypeParameters.Add(symbol);
 }

        /// <summary>
        /// Examines the identifier and if applicable, creates an instance of ObjectInformation
        /// which will be consumed later by the SyntaxBuilder
        /// </summary>
        /// <param name="node"></param>
        private void processIdentifierName(IdentifierNameSyntax node)
        {
            var symbol = _model.GetSymbolInfo(node).Symbol;
            var type = _model.GetTypeInfo(node).Type;
            if (type == null || symbol == null)
            {
                // We need a symbol
                // Method names are an example of identifiers with no types, and we ignore them
                return;
            }
            if (node.IsVar)
            {
                return;
            }
            if (symbol != null)
            {
                var typeName = type?.Name ?? String.Empty;
                // Handle generics (TODO: recursively go through all levels)
                var namedType = type as INamedTypeSymbol;
                if (namedType != null)
                {
                    List<string> argumentNames = new List<string>();
                    foreach (var argument in namedType.TypeArguments)
                    {
                        var argumentName = argument.Name;
                        argumentNames.Add(argumentName);
                    }
                    if (argumentNames.Any())
                    {
                        typeName = $"{type?.Name}<{String.Join(", ", argumentNames)}>";
                    }
                }

                // Attempt to remove trivial identifiers like String.Empty
                var definitionName = symbol.OriginalDefinition.ToDisplayString();
                var actualName = typeName + "." + symbol.MetadataName;
                if (String.Compare(definitionName, actualName, ignoreCase: true) == 0)
                {
                    // This identifier is already well defined in the snippet.
                    return;
                }

                foreach (var location in symbol.OriginalDefinition.Locations)
                {
                    // Process only nodes defined outside of the target range
                    if (!location.IsInSource || !(location.SourceSpan.Start < _end && location.SourceSpan.End > _start))
                    {
                        var objectInfo = new ObjectInformation()
                        {
                            Identifier = node?.Identifier.ToString() ?? String.Empty,
                            TypeName = typeName ?? String.Empty,
                            Namespace = type?.ContainingNamespace?.ToString() ?? String.Empty,
                            AssemblyName = type?.ContainingAssembly?.Name ?? String.Empty,
                            Kind = symbol.Kind,
                        };
                        definedWithinSnippet.Add(objectInfo);
                    }
                }
            }
        }

        public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
        {
            if (node.Identifier.ToString() == renameFrom.ToString())
                return SyntaxFactory.IdentifierName(renameTo);

            return base.VisitIdentifierName(node);
        }

        private async Task<Document> InsertStopwatchToMeasureTime(Document document, IdentifierNameSyntax node, CancellationToken cancellationToken) {
            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken);
            var nodes = new List<Tuple<SyntaxNode, SyntaxNode>>();

            SyntaxNode nodeLine = GetRootNodeOfLine(node);
            SyntaxNode newNode = CommentLine(nodeLine);
            newNode = newNode.WithTrailingTrivia(newNode.GetTrailingTrivia()
                .AddRange(nodeLine.GetLeadingTrivia())
                .Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "timer.Stop();"))
                .Add(SyntaxFactory.EndOfLine(Environment.NewLine))
                .AddRange(nodeLine.GetLeadingTrivia())
                .Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "TimeSpan elapsed = timer.Elapsed;"))
                .Add(SyntaxFactory.EndOfLine(Environment.NewLine)));

            nodes.Add(new Tuple<SyntaxNode, SyntaxNode>(nodeLine, newNode));

            var methodDeclaration = node.FirstAncestorOfType(typeof(MethodDeclarationSyntax)) as MethodDeclarationSyntax;
            if (semanticModel == null) { return document; }
            SyntaxNode firstGetTime = TimeMeasurementCodeAnalyzer.GetNodesUsedToGetCurrentTime(semanticModel, methodDeclaration).First();
            nodeLine = GetRootNodeOfLine(firstGetTime);
            newNode = CommentLine(nodeLine);
            newNode = newNode.WithTrailingTrivia(newNode.GetTrailingTrivia()
                .AddRange(nodeLine.GetLeadingTrivia())
                .Add(SyntaxFactory.SyntaxTrivia(SyntaxKind.SingleLineCommentTrivia, "var timer = Stopwatch.StartNew();"))
                .Add(SyntaxFactory.EndOfLine(Environment.NewLine)));

            nodes.Add(new Tuple<SyntaxNode, SyntaxNode>(nodeLine, newNode));

            document = await this.ReplaceNodesInDocumentAsync(document, cancellationToken, nodes.ToArray());
            return await this.CheckNamespaceUsageAsync(document, cancellationToken, "System.Diagnostics");
        }

        public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
        {
            if (!(node.Parent is MemberAccessExpressionSyntax) || ((MemberAccessExpressionSyntax)node.Parent).Expression == node)
            {
                if (node.GetContainingMethod() == null)
                {
                    return base.VisitIdentifierName(node);
                }

                var containingType = node.GetContainingType();
                if (containingType == null || !containingType.Name.StartsWith(enclosingTypeName))
                    return node;

                var symbol = semanticModel.GetSymbolInfo(node).Symbol;
                var isObjectInitializer = node.Parent != null && node.Parent.Parent is InitializerExpressionSyntax;
                if (!isObjectInitializer)
                {
                    if (symbol == null || (new[] { SymbolKind.Field, SymbolKind.Event, SymbolKind.Method, SymbolKind.Property }.Contains(symbol.Kind) && !symbol.ContainingType.Name.StartsWith(enclosingTypeName) && !symbol.IsStatic))
                    {
                        return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_this"), node);
                    }
                }
            }
            return base.VisitIdentifierName(node);
        }

		private static void AnalyzeTypeNode(
			SyntaxNodeAnalysisContext context,
			Location location,
			IdentifierNameSyntax typeNode) {
			if (typeNode == null || typeNode.IsVar) return;

			var classSymbol = context.SemanticModel.GetSymbolInfo(typeNode).Symbol as INamedTypeSymbol;
			if (classSymbol == null) return;
			if (classSymbol.TypeKind != TypeKind.Class) return;
			if (classSymbol.AllInterfaces.Count() != 1) return;
			if (!classSymbol.CanBeReferencedByName) return;

			var interfaceSymbol = classSymbol.AllInterfaces.Single();
			if (!interfaceSymbol.CanBeReferencedByName) return;

			context.ReportDiagnostic(
				Diagnostic.Create(
					Rule,
					location,
					properties: ImmutableDictionary.Create<string, string>()
						.Add("interfaceName", interfaceSymbol.Name)
						.Add("interfaceNamespace", interfaceSymbol.ContainingNamespace.Name)
						.Add("className", classSymbol.Name),
					messageArgs: new[] { classSymbol.Name, interfaceSymbol.Name }
			));
		}

		private Document IntroduceLocalDeclarationIntoLambda(
			SemanticDocument document,
			ExpressionSyntax expression,
			IdentifierNameSyntax newLocalName,
			LocalDeclarationStatementSyntax declarationStatement,
			SyntaxNode oldLambda,
			bool allOccurrences,
			CancellationToken cancellationToken)
		{
			var oldBody = oldLambda is ParenthesizedLambdaExpressionSyntax
				? (ExpressionSyntax)((ParenthesizedLambdaExpressionSyntax)oldLambda).Body
			                                                                        : (ExpressionSyntax)((SimpleLambdaExpressionSyntax)oldLambda).Body;

			var rewrittenBody = Rewrite(
				document, expression, newLocalName, document, oldBody, allOccurrences, cancellationToken);

			var delegateType = document.SemanticModel.GetTypeInfo(oldLambda, cancellationToken).ConvertedType as INamedTypeSymbol;

			var newBody = delegateType != null && delegateType.DelegateInvokeMethod != null && delegateType.DelegateInvokeMethod.ReturnsVoid
			                                                  ? SyntaxFactory.Block(declarationStatement)
			                                                  : SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(rewrittenBody));

			newBody = newBody.WithAdditionalAnnotations(Formatter.Annotation);

			var newLambda = oldLambda is ParenthesizedLambdaExpressionSyntax
				? ((ParenthesizedLambdaExpressionSyntax)oldLambda).WithBody(newBody)
			                                                      : (SyntaxNode)((SimpleLambdaExpressionSyntax)oldLambda).WithBody(newBody);

			var newRoot = document.Root.ReplaceNode(oldLambda, newLambda);
			return document.Document.WithSyntaxRoot(newRoot);
		}

        /// <summary>
        /// Rewrites the expression with a field access expression.
        /// </summary>
        /// <param name="node">IdentifierNameSyntax</param>
        /// <returns>SyntaxNode</returns>
        private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
        {
            SyntaxNode rewritten = node;

            if (!base.IsInStateScope(rewritten) ||
                !(base.IsMachineField(rewritten) || base.IsMachineMethod(rewritten)))
            {
                return rewritten;
            }

            if (!(rewritten.Parent is MemberAccessExpressionSyntax) &&
                !(rewritten.Parent is ObjectCreationExpressionSyntax) &&
                !(rewritten.Parent is TypeOfExpressionSyntax))
            {
                var text = "this." + node.ToString();

                rewritten = SyntaxFactory.ParseExpression(text);
                rewritten = rewritten.WithTriviaFrom(node);
            }

            if ((rewritten.Parent is MemberAccessExpressionSyntax) &&
                (rewritten.Parent as MemberAccessExpressionSyntax).Expression is IdentifierNameSyntax &&
                ((rewritten.Parent as MemberAccessExpressionSyntax).Expression as IdentifierNameSyntax).
                IsEquivalentTo(node))
            {
                var text = "this." + node.ToString();

                rewritten = SyntaxFactory.ParseExpression(text);
                rewritten = rewritten.WithTriviaFrom(node);
            }

            return rewritten;
        }

        //--- Class Methods ---
        public static IEnumerable<ISymbol> GetMissingEnumMembers(SwitchStatementSyntax switchNode, SemanticModel semanticModel, out IdentifierNameSyntax switchVariable)
        {
            // TODO (2016-02-25, steveb): what if the swich calls a function instead?
            switchVariable = switchNode.Expression as IdentifierNameSyntax;
            if(switchVariable == null) {
                return Enumerable.Empty<ISymbol>();
            }
            var switchVariableTypeInfo = semanticModel.GetTypeInfo(switchVariable);

            // check if we are switching over an enum
            if((switchVariableTypeInfo.Type != null) && (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.Sections
                    .SelectMany(section => section.Labels)
                    .Select(label => label.DescendantNodes().OfType<MemberAccessExpressionSyntax>().FirstOrDefault())
                    .Where(memberAccess => memberAccess != null)
                    .Select(memberAccess => semanticModel.GetSymbolInfo(memberAccess).Symbol)
                    .ToImmutableHashSet();

                // make sure we have all cases covered
                return enumMembers.Where(x => !caseSwitchLabels.Contains(x)).ToImmutableArray();
            }
            return Enumerable.Empty<ISymbol>();
        }

 protected NavInvocationAnnotation(NavTaskAnnotation taskAnnotation, 
                                   IdentifierNameSyntax identifier): base(taskAnnotation) {
     if(identifier == null) {
         throw new ArgumentNullException(nameof(identifier));
     }
     Identifier = identifier;
 }

 /// <summary>
 /// Called by the base class. Processes identifiers that are in desired range.
 /// </summary>
 /// <param name="node"></param>
 public override void VisitIdentifierName(IdentifierNameSyntax node)
 {
     // Process only nodes in the target range
     if (node.Span.Start < _end && node.Span.End > _start)
     {
         processIdentifierName(node);
     }
 }

        /// <summary>
        /// Rewrites the expression with a trigger expression.
        /// </summary>
        /// <param name="node">IdentifierNameSyntax</param>
        /// <returns>SyntaxNode</returns>
        private SyntaxNode RewriteExpression(IdentifierNameSyntax node)
        {
            var text = "this.ReceivedEvent";
            var rewritten = SyntaxFactory.ParseExpression(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

        public ExceptionReference(ISymbol symbol, IdentifierNameSyntax identifier)
        {
            Contract.Requires(symbol != null);
            Contract.Requires(identifier != null);

            Symbol = symbol;
            Identifier = identifier;
        }

 /// <summary>
 /// Create If statement that execute yield return if not completed the <see cref="Task"/> or <see cref="Task{T}"/> object.
 /// </summary>
 /// <remarks>
 /// if (!task.IsCompleted)
 ///     yield return task;
 /// </remarks>
 private static SyntaxNode CreateYieldReturnIfNotCompleted(IdentifierNameSyntax task)
 {
     return SyntaxFactory.IfStatement(
         SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.Token(SyntaxKind.ExclamationToken),
             SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, task, SyntaxFactory.IdentifierName("IsCompleted"))
         ),
         SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, task)
     );
 }

        /// <summary>
        /// Rewrites the type with a halt event type.
        /// </summary>
        /// <param name="node">IdentifierNameSyntax</param>
        /// <returns>ExpressionSyntax</returns>
        private ExpressionSyntax RewriteType(IdentifierNameSyntax node)
        {
            var text = typeof(Halt).FullName;

            var rewritten = SyntaxFactory.ParseName(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

        public NavInitCallAnnotation(NavTaskAnnotation taskAnnotation, 
                                        IdentifierNameSyntax identifier, 
                                        string beginItfFullyQualifiedName, 
                                        List<string> parameter)
            : base(taskAnnotation, identifier) {

            BeginItfFullyQualifiedName = beginItfFullyQualifiedName ?? String.Empty;
            Parameter                  = (parameter ?? new List<string>()).ToImmutableList();
        }

 public override void VisitIdentifierName(IdentifierNameSyntax node)
 {
     base.VisitIdentifierName(node);
     if (!IsTargetOfInvocation(node)) {
         var mgr = ctx.GetSymbolInfo(node);
         if (mgr.Symbol?.IsKind(SymbolKind.Method) == true)
             UsedMethods.Add(mgr.Symbol);
     }
 }

        /// <summary>
        /// Rewrites the type with a halt event type.
        /// </summary>
        /// <param name="node">IdentifierNameSyntax</param>
        /// <returns>ExpressionSyntax</returns>
        private ExpressionSyntax RewriteType(IdentifierNameSyntax node)
        {
            var text = "Halt";

            var rewritten = SyntaxFactory.ParseExpression(text);
            rewritten = rewritten.WithTriviaFrom(node);

            return rewritten;
        }

        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;
        }