public void AddError(DiagnosticBase diagnostic, TextSpan span)
        {
            lock (_lockObject)
            {
                if (_disposed)
                    return;

                var sourceText = span.SourceText as VisualStudioSourceText;
                if (sourceText == null)
                    return;

                var line = sourceText.Snapshot.GetLineFromPosition(span.Start);

                var task = new ErrorTask
                {
                    Text = diagnostic.Message,
                    Line = line.LineNumber,
                    Column = span.Start - line.Start.Position,
                    Category = TaskCategory.CodeSense,
                    ErrorCategory = (diagnostic.Severity == DiagnosticSeverity.Error)
                        ? TaskErrorCategory.Error
                        : TaskErrorCategory.Warning,
                    Priority = TaskPriority.Normal,
                    Document = span.Filename ?? _textDocument.FilePath
                };

                task.Navigate += OnTaskNavigate;

                _errorListProvider.Tasks.Add(task);
            }
        }

        public void AddError(Project project, string path, string errorText, TaskErrorCategory category, int iLine, int iColumn)
        {
            ErrorTask task;
              IVsSolution solution;
              IVsHierarchy hierarchy;

              if (project != null)
              {
              try
              {
              solution = (IVsSolution)GetService(typeof(IVsSolution));
              ErrorHandler.ThrowOnFailure(solution.GetProjectOfUniqueName(project.UniqueName, out hierarchy));

              task = new ErrorTask();
              task.ErrorCategory = category;
              task.HierarchyItem = hierarchy;
              task.Document = path;

              // VS uses indexes starting at 0 while the automation model uses indexes starting at 1
              task.Line = iLine - 1;
              task.Column = iColumn;
              task.Text = errorText;
              task.Navigate += ErrorTaskNavigate;
              if (ContainsLink(errorText))
              {
                  task.Help += new EventHandler(task_Help);
              }
              _errorListProvider.Tasks.Add(task);
              }
              catch (Exception ex)
              {
              MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
              }
              }
        }

        private void CreateErrors()
        {
            var errors = errorListProvider.GetErrors(textView.TextBuffer);

            // Check if we should update the error list based on the error count to avoid refreshing the list without changes
            if (errors.Count != this.previousErrors.Count)
            {
                // remove any previously created errors to get a clean start
                ClearErrors();

                foreach (ValidationError error in errors)
                {
                    // creates the instance that will be added to the Error List
                    ErrorTask task = new ErrorTask();
                    task.Category = TaskCategory.All;
                    task.Priority = TaskPriority.Normal;
                    task.Document = textView.TextBuffer.Properties.GetProperty<ITextDocument>(typeof(ITextDocument)).FilePath;
                    task.ErrorCategory = TranslateErrorCategory(error.Severity);
                    task.Text = error.Description;
                    task.Line = textView.TextSnapshot.GetLineNumberFromPosition(error.Span.Start);
                    task.Column = error.Span.Start - textView.TextSnapshot.GetLineFromLineNumber(task.Line).Start;
                    task.Navigate += OnTaskNavigate;
                    errorList.Tasks.Add(task);
                    previousErrors.Add(task);

                    ITrackingSpan span = textView.TextSnapshot.CreateTrackingSpan(error.Span, SpanTrackingMode.EdgeNegative);
                    squiggleTagger.CreateTagSpan(span, new ErrorTag("syntax error", error.Description));
                    previousSquiggles.Add(new TrackingTagSpan<IErrorTag>(span, new ErrorTag("syntax error", error.Description)));
                }
            }
        }

 public void LogError(Exception ex)
 {
     ErrorTask task = new ErrorTask(ex);
     task.ErrorCategory = TaskErrorCategory.Error;
     task.Category = TaskCategory.Misc;
     m_errorListPrivider.Tasks.Add(task);
 }

        public static void AddHierarchyItem(ErrorTask task, EnvDTE.Project project)
        {
            IVsHierarchy hierarchyItem = null;
            IVsSolution solution = BundlerMinifierPackage.GetGlobalService(typeof(SVsSolution)) as IVsSolution;

            if (solution != null && project != null)
            {
                int flag = -1;

                try
                {
                    flag = solution.GetProjectOfUniqueName(project.FullName, out hierarchyItem);
                }
                catch (COMException ex)
                {
                    if ((uint)ex.ErrorCode != DISP_E_MEMBERNOTFOUND)
                    {
                        throw;
                    }
                }

                if (0 == flag)
                {
                    task.HierarchyItem = hierarchyItem;
                }
            }
        }

        public static void Show(Diagnostic diag)
        {
            var task = new ErrorTask
                           {
                               Text = string.Format(@"[N] {0,4} : {1}", diag.ID, diag.Message),
                               Category = TaskCategory.CodeSense,
                               ErrorCategory =
                                   diag.Level == DiagnosticLevel.Warning
                                       ? TaskErrorCategory.Warning
                                       : TaskErrorCategory.Error,
                               Column = diag.StartColumn,
                               Line = diag.StartLine - 1,
                               Document = diag.FilePath,
                               HierarchyItem = (IVsHierarchy)(AVRStudio.GetProjectItem(dte, diag.FilePath).ContainingProject != null ? AVRStudio.GetProjectItem(dte, diag.FilePath).ContainingProject.Object : null),
                           };

            task.Navigate += (sender, args) =>
                                 {
                                     task.Line++;
                                     errorListProvider.Navigate(task, Guid.Parse(EnvDTE.Constants.vsViewKindCode));
                                     task.Line--;
                                 };

            errorListProvider.Tasks.Add(task);
        }

 public virtual void ShowError(string error)
 {
     var errorTask = new ErrorTask
                         {
                             Category = TaskCategory.Misc,
                             Text = error,
                             CanDelete = true,
                         };
     errorProvider.Tasks.Add(errorTask);
 }

 public void Add(Project project, TaskErrorCategory category, string file, int line, int column, string description)
 {
     var task = new ErrorTask
     {
         ErrorCategory = category,
         Document = file,
         Line = Math.Max(line - 1, 0),
         Column = Math.Max(column - 1, 0),
         Text = description,
     };
     this.Add(project, task);
 }

        /// <summary>
        /// Adds a message of the given document to the error list.
        /// </summary>
        public void AddMessage(string message, string document, ErrorCategory errorCategory)
        {
            var errorTask = new ErrorTask
                {
                    ErrorCategory = (TaskErrorCategory)errorCategory,
                    Text = message,
                    Document = document,
                };

            this.ErrorListProvider.Tasks.Add(errorTask);
            this.ErrorListProvider.Show();
            this.ErrorListProvider.BringToFront();
        }

        public void Can_add_clear_error_list_tasks()
        {
            var mockServiceProvider = new Mock<IServiceProvider>();
            mockServiceProvider.Setup(p => p.GetService(typeof(SVsTaskList))).Returns(new Mock<IVsTaskList>().Object);

            var task = new ErrorTask();
            var errorList = new DesignerErrorList(mockServiceProvider.Object);

            Assert.Empty(errorList.Provider.Tasks);
            errorList.AddItem(task);
            Assert.Equal(new[] { task }, errorList.Provider.Tasks.Cast<ErrorTask>());
            errorList.Clear();
            Assert.Empty(errorList.Provider.Tasks);
        }

 /// <summary>
 /// Creates task from occurence
 /// </summary>
 /// <param name="occurence"> occurence of defect</param>
 /// <param name="fileName">file name of occurence</param>
 /// <returns></returns>
 Task CreateTask(Occurence occurence, string fileName)
 {
     var defectTask = new ErrorTask()
     {
         Category = TaskCategory.User,
         ErrorCategory = TaskErrorCategory.Warning,
         CanDelete = false,
         Text = occurence.Message,
         Document = fileName,
         Line = int.Parse(occurence.StartLine)
     };
     defectTask.Navigate += navigateEventHandler;
     return defectTask;
 }

        /// <summary>
        /// Adds an error message to the Visual Studio tasks pane
        /// </summary>
        private void ShowError(string path, string text)
        {
            _message = new ErrorTask
            {
                ErrorCategory = TaskErrorCategory.Error,
                Category = TaskCategory.Comments,
                Document = path,
                Line = 0,
                Column = 0,
                Text = text
            };

            _messageList.Tasks.Add(_message);
            _messageList.Show();
        }

        public void AddHierarchyItem(ErrorTask task)
        {
            IVsHierarchy HierarchyItem;
            IVsSolution solution = EditorExtensionsPackage.GetGlobalService<IVsSolution>(typeof(SVsSolution));

            if (solution != null)
            {
                int flag = solution.GetProjectOfUniqueName(_connection.Project.FullName, out HierarchyItem);

                if (0 == flag)
                {
                    task.HierarchyItem = HierarchyItem;
                }
            }
        }

        public static Task ProduceErrorListTask(this IStylingRule rule, TaskErrorCategory category, Project project, string format)
        {
            var item = ResolveVsHierarchyItem(project.UniqueName);

            var task = new ErrorTask
            {
                Document = rule.File,
                Line = rule.Line - 1,
                Column = rule.Column,
                ErrorCategory = category,
                Category = TaskCategory.Html,
                Text = string.Format(format, project.Name, rule.DisplaySelectorName, rule.File, rule.Line, rule.Column),
                HierarchyItem = item
            };

            task.Navigate += NavigateToItem;
            return task;
        }

        public void AddError(ITextSnapshot snapshot, Diagnostic diagnostic, TextSpan span)
        {
            var line = snapshot.GetLineFromPosition(span.Start);

            var task = new ErrorTask
            {
                Text = diagnostic.Message,
                Line = line.LineNumber,
                Column = span.Start - line.Start.Position,
                Category = TaskCategory.CodeSense,
                ErrorCategory = TaskErrorCategory.Error,
                Priority = TaskPriority.Normal,
                Document = span.Filename
            };

            task.Navigate += OnTaskNavigate;

            _errorListProvider.Tasks.Add(task);
        }

        private IEnumerable<IGooseErrorTask> BuildErrorTask(ShellCommand command, string content)
        {
            var output = this.logParser.Parse(content);

            return output.Results
                         .Where(error => error.Type.Equals(CommandOutputItemType.Error))
                         .Select(error =>
                             {
                                 var errorTask = new ErrorTask
                                     {
                                         CanDelete = true,
                                         Column = 0,
                                         Line = (int) error.Line,
                                         Document = error.FullPath,
                                         Text = string.Format("{0}{1}{2}", error.Message, Environment.NewLine, error.Excerpt)
                                     };
                                 return new GooseErrorTask(command, errorTask);
                             });
        }

 public static ErrorTask add_Task(this ErrorListProvider errorListProvider, TaskErrorCategory errorCategory, string text, string file = null, int line = 1, int column= 1)
 {
     var errorTask = new ErrorTask()
     {
         ErrorCategory = errorCategory,
         Category = TaskCategory.BuildCompile,
         Text = text,
         Document 	 = file, 
         Line = line -1,
         Column = column -1,
         //HierarchyItem = hierarchyItem			
     };
     errorListProvider.Tasks.Add(errorTask);
     errorTask.Navigate += (sender,e)=> {
     										file.open_Document();
     										(VisualStudio_2010.DTE2.ActiveDocument.Selection as EnvDTE.TextSelection).GotoLine(line, true);
     									};
     return errorTask;
 }

    public void Write(TaskCategory category, TaskErrorCategory errorCategory, string text, string document, int? line = null, int? column = null)
    {
      ErrorTask task = new ErrorTask();
      task.Text = text;
      task.ErrorCategory = errorCategory;

      int? startLine, startColumn, endLine, endColumn;
      ParseErrorLocation(text, out startLine, out startColumn, out endLine, out endColumn);

      task.Line = (line ?? startLine ?? 1) - 1;
      task.Column = (column ?? startColumn ?? 1) - 1;
      task.Document = document;
      task.Category = category;

      if (!string.IsNullOrEmpty(document))
      {
        task.Navigate += NavigateDocument;
      }
      _errorListProvider.Tasks.Add(task);
    }

        private static void AddHierarchyItem(ErrorTask task, EnvDTE.Project project)
        {
            IVsSolution solution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution;

            if (solution == null || project == null)
                return;

            try
            {
                IVsHierarchy hierarchyItem = null;
                if (solution.GetProjectOfUniqueName(project.FullName, out hierarchyItem) == 0)
                {
                    task.HierarchyItem = hierarchyItem;
                }
            }
            catch (COMException ex)
            {
                Logger.Log(ex);
            }
        }

        private IErrorItem Add(string text, Action<IErrorItem> handler, bool isWarning)
        {
            var errorTask = new ErrorTask();

            errorTask.Category = TaskCategory.Misc;
            errorTask.ErrorCategory = isWarning ? TaskErrorCategory.Warning : TaskErrorCategory.Error;
            errorTask.Text = text;

            var errorItem = new ErrorItem(this.errorListProvider, errorTask);

            errorTask.Navigate += (sender, e) =>
            {
                if (handler != null)
                    handler(errorItem);
            };

            this.errorListProvider.Tasks.Add(errorTask);

            return errorItem;
        }