protected Task RaiseWorkspaceChangedEventAsync(WorkspaceChangeKind kind, Solution oldSolution, Solution newSolution, ProjectId projectId = null, DocumentId documentId = null)
        {
            if (newSolution == null)
            {
                throw new ArgumentNullException(nameof(newSolution));
            }

            if (oldSolution == newSolution)
            {
                return SpecializedTasks.EmptyTask;
            }

            if (projectId == null && documentId != null)
            {
                projectId = documentId.ProjectId;
            }

            var ev = _eventMap.GetEventHandlers<EventHandler<WorkspaceChangeEventArgs>>(WorkspaceChangeEventName);
            if (ev.HasHandlers)
            {
                return this.ScheduleTask(() =>
                {
                    var args = new WorkspaceChangeEventArgs(kind, oldSolution, newSolution, projectId, documentId);
                    ev.RaiseEvent(handler => handler(this, args));
                }, "Workspace.WorkspaceChanged");
            }
            else
            {
                return SpecializedTasks.EmptyTask;
            }
        }

 public DiagnosticsUpdatedArgs(
     object id, Workspace workspace, Solution solution, ProjectId projectId, DocumentId documentId, ImmutableArray<DiagnosticData> diagnostics) :
         base(id, workspace, projectId, documentId)
 {
     this.Solution = solution;
     this.Diagnostics = diagnostics;
 }

        internal void ReportAnalyzerDiagnostic(DiagnosticAnalyzer analyzer, Diagnostic diagnostic, Workspace workspace, ProjectId projectId)
        {
            if (workspace != this.Workspace)
            {
                return;
            }

            var project = workspace.CurrentSolution.GetProject(projectId);

            bool raiseDiagnosticsUpdated = true;
            var diagnosticData = project != null ?
                DiagnosticData.Create(project, diagnostic) :
                DiagnosticData.Create(this.Workspace, diagnostic);

            var dxs = ImmutableInterlocked.AddOrUpdate(ref s_analyzerHostDiagnosticsMap,
                analyzer,
                ImmutableHashSet.Create(diagnosticData),
                (a, existing) =>
                {
                    var newDiags = existing.Add(diagnosticData);
                    raiseDiagnosticsUpdated = newDiags.Count > existing.Count;
                    return newDiags;
                });

            if (raiseDiagnosticsUpdated)
            {
                RaiseDiagnosticsUpdated(MakeArgs(analyzer, dxs, project));
            }
        }

 private void ClearAnalyzerDiagnostics(ImmutableArray<DiagnosticAnalyzer> analyzers, ProjectId projectId)
 {
     foreach (var analyzer in analyzers)
     {
         ClearAnalyzerDiagnostics(analyzer, projectId);
     }
 }

            public DiagnosticGetter(
                DiagnosticIncrementalAnalyzer owner,
                Solution solution,
                ProjectId projectId,
                DocumentId documentId,
                object id,
                bool includeSuppressedDiagnostics)
            {
                Owner = owner;
                CurrentSolution = solution;

                CurrentDocumentId = documentId;
                CurrentProjectId = projectId ?? documentId?.ProjectId;

                Id = id;
                IncludeSuppressedDiagnostics = includeSuppressedDiagnostics;

                // try to retrieve projectId/documentId from id if possible.
                var argsId = id as LiveDiagnosticUpdateArgsId;
                if (argsId != null)
                {
                    CurrentDocumentId = CurrentDocumentId ?? argsId.Key as DocumentId;
                    CurrentProjectId = CurrentProjectId ?? (argsId.Key as ProjectId) ?? CurrentDocumentId.ProjectId;
                }

                _builder = null;
            }

            public void RemoveProject(ProjectId projectId)
            {
                long unused;
                _map.TryRemove(projectId, out unused);

                _size = _map.Values.Sum();
            }

        protected override Solution CreateSolution(ProjectId projectId, string language)
        {
            Solution solution = base.CreateSolution(projectId, language);
            Project project = solution.GetProject(projectId);

            return solution.WithProjectParseOptions(projectId, project.ParseOptions.WithDocumentationMode(this.documentationMode));
        }

 public void UpdateReferences(ProjectId projectId, FrameworkProject frameworkProject)
 {
     DnxProject project = FindProject (projectId);
     if (project != null) {
         UpdateReferences (project, frameworkProject);
     }
 }

 protected AbstractAddRemoveUndoUnit(
     VisualStudioWorkspaceImpl workspace,
     ProjectId fromProjectId)
 {
     Workspace = workspace;
     FromProjectId = fromProjectId;
 }

        void IProjectView.ShowView(FilteredProject project)
        {
            _region.SwitchTo("project-view");

            this.Sync(() =>
                {
                    _project = project.Info.ProjectId;
                    _projectName.Text = string.Format("{0} ({1})", project.Info.Outcome, project.ActionCount);

                    // TODO: smarter update for the case when we remove item
                    if (_source.Count == project.FilteredActions.Count)
                    {
                        for (int i = 0; i < project.FilteredActions.Count; i++)
                        {
                            _source[i] = new ActionDisplay(project.FilteredActions[i], this);
                        }
                        return;
                    }

                    _source.Clear();
                    foreach (var action in project.FilteredActions)
                    {
                        _source.Add(new ActionDisplay(action, this));
                    }
                });
        }

        private DiagnosticData CreateDiagnostic(ProjectId projectId, AnalyzerDependencyConflict conflict)
        {
            string id = ServicesVSResources.WRN_AnalyzerDependencyConflictId;
            string category = ServicesVSResources.ErrorCategory;
            string message = string.Format(
                ServicesVSResources.WRN_AnalyzerDependencyConflictMessage,
                conflict.DependencyFilePath1,
                Path.GetFileNameWithoutExtension(conflict.AnalyzerFilePath1),
                conflict.DependencyFilePath2,
                Path.GetFileNameWithoutExtension(conflict.AnalyzerFilePath2));

            DiagnosticData data = new DiagnosticData(
                id,
                category,
                message,
                ServicesVSResources.WRN_AnalyzerDependencyConflictMessage,
                severity: DiagnosticSeverity.Warning,
                defaultSeverity: DiagnosticSeverity.Warning,
                isEnabledByDefault: true,
                warningLevel: 0,
                customTags: ImmutableArray<string>.Empty,
                workspace: _workspace,
                projectId: projectId);

            return data;
        }

 public UpdatedEventArgs(object id, Workspace workspace, ProjectId projectId, DocumentId documentId)
 {
     this.Id = id;
     this.Workspace = workspace;
     this.ProjectId = projectId;
     this.DocumentId = documentId;
 }

 public TodoItemsUpdatedArgs(
     object id, Workspace workspace, Solution solution, ProjectId projectId, DocumentId documentId, ImmutableArray<TodoItem> todoItems) :
     base(id, workspace, projectId, documentId)
 {
     this.Solution = solution;
     this.TodoItems = todoItems;
 }

 public ActionAssignedToProject(TenantId id, ActionId action, ProjectId newProject, DateTime timeUtc)
 {
     Id = id;
     Action = action;
     NewProject = newProject;
     TimeUtc = timeUtc;
 }

 public void RemoveProject(ProjectId projectId)
 {
     foreach (var documentId in _map.Keys.Where(id => id.ProjectId == projectId).ToArray())
     {
         RemoveDocument(documentId);
     }
 }

 public DiagnosticData(
     string id,
     string category,
     string message,
     string enuMessageForBingSearch,
     DiagnosticSeverity severity,
     bool isEnabledByDefault,
     int warningLevel,
     Workspace workspace,
     ProjectId projectId,
     DocumentId documentId = null,
     TextSpan? span = null,
     string originalFilePath = null,
     int originalStartLine = 0,
     int originalStartColumn = 0,
     int originalEndLine = 0,
     int originalEndColumn = 0,
     string title = null,
     string description = null,
     string helpLink = null) :
         this(
             id, category, message, enuMessageForBingSearch,
             severity, severity, isEnabledByDefault, warningLevel,
             ImmutableArray<string>.Empty, ImmutableDictionary<string, string>.Empty,
             workspace, projectId, documentId, span,
             null, originalStartLine, originalStartColumn, originalEndLine, originalEndColumn,
             originalFilePath, originalStartLine, originalStartColumn, originalEndLine, originalEndColumn,
             title, description, helpLink)
 {
 }

        public async Task<Compilation> GetCompilationAsync(Checksum solutionChecksum, ProjectId projectId, CancellationToken cancellationToken)
        {
            var solution = await RoslynServices.SolutionService.GetSolutionAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);

            // TODO: need to figure out how to deal with exceptions in service hub
            return await solution.GetProject(projectId).GetCompilationAsync(cancellationToken).ConfigureAwait(false);
        }

            public async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(Solution solution, ProjectId projectId, DocumentId documentId, CancellationToken cancellationToken)
            {
                if (solution == null)
                {
                    return GetDiagnosticData();
                }

                if (documentId != null)
                {
                    var document = solution.GetDocument(documentId);

                    await AppendDiagnosticsAsync(document, cancellationToken).ConfigureAwait(false);
                    await AppendProjectAndDocumentDiagnosticsAsync(document.Project, document, d => d.DocumentId == documentId, cancellationToken).ConfigureAwait(false);
                    return GetDiagnosticData();
                }

                if (projectId != null)
                {
                    await AppendDiagnosticsAsync(solution.GetProject(projectId), cancellationToken: cancellationToken).ConfigureAwait(false);
                    return GetDiagnosticData();
                }

                await AppendDiagnosticsAsync(solution, cancellationToken: cancellationToken).ConfigureAwait(false);
                return GetDiagnosticData();
            }

 public SolutionPreviewItem(ProjectId projectId, DocumentId documentId, string text)
 {
     ProjectId = projectId;
     DocumentId = documentId;
     Text = text;
     LazyPreview = c => Task.FromResult<object>(text);
 }

        public IList<string> GetFolders(ProjectId projectId, Workspace workspace)
        {
            var folders = new List<string>();

            if (workspace is VisualStudioWorkspaceImpl)
            {
                ((VisualStudioWorkspaceImpl)workspace).GetProjectData(projectId, out var ivisualStudioHostProject, out var hierarchy, out var envDTEProject);

                var projectItems = envDTEProject.ProjectItems;

                var projectItemsStack = new Stack<Tuple<ProjectItem, string>>();

                // Populate the stack
                projectItems.OfType<ProjectItem>().Where(n => n.IsFolder()).Do(n => projectItemsStack.Push(Tuple.Create(n, "\\")));
                while (projectItemsStack.Count != 0)
                {
                    var projectItemTuple = projectItemsStack.Pop();
                    var projectItem = projectItemTuple.Item1;
                    var currentFolderPath = projectItemTuple.Item2;

                    var folderPath = currentFolderPath + projectItem.Name + "\\";

                    folders.Add(folderPath);
                    projectItem.ProjectItems.OfType<ProjectItem>().Where(n => n.IsFolder()).Do(n => projectItemsStack.Push(Tuple.Create(n, folderPath)));
                }
            }

            return folders;
        }