Ejemplo n.º 1
0
        private async Task <AddMessageResult> AddMessageCoreAsync(TargetGeneratedError error)
        {
            // We only want to pass compiler, analyzers, etc to the language
            // service, so we skip tasks that do not have a code
            if (!TryExtractErrorListDetails(error.BuildEventArgs, out ErrorListDetails details) || string.IsNullOrEmpty(details.Code))
            {
                return(AddMessageResult.NotHandled);
            }

            bool handled = await _projectContextHost.OpenContextForWriteAsync(accessor =>
            {
                var errorReporter = (IVsLanguageServiceBuildErrorReporter2)accessor.HostSpecificErrorReporter;

                try
                {
                    errorReporter.ReportError2(details.Message,
                                               details.Code,
                                               details.Priority,
                                               details.LineNumberForErrorList,
                                               details.ColumnNumberForErrorList,
                                               details.EndLineNumberForErrorList,
                                               details.EndColumnNumberForErrorList,
                                               details.GetFileFullPath(_project.FullPath));
                    return(TaskResult.True);
                }
                catch (NotImplementedException)
                {   // Language Service doesn't handle it, typically because file
                    // isn't in the project or because it doesn't have line/column
                }

                return(TaskResult.False);
            });

            return(handled ? AddMessageResult.HandledAndStopProcessing : AddMessageResult.NotHandled);
        }
        private async Task <AddMessageResult> AddMessageCoreAsync(TargetGeneratedError error)
        {
            // We only want to pass compiler, analyzers, etc to the language
            // service, so we skip tasks that do not have a code
            if (!TryExtractErrorListDetails(error.BuildEventArgs, out ErrorListDetails details) || string.IsNullOrEmpty(details.Code))
            {
                return(await NotHandled.ConfigureAwait(false));
            }

            InitializeBuildErrorReporter();

            bool handled = false;

            if (_languageServiceBuildErrorReporter != null)
            {
                try
                {
                    _languageServiceBuildErrorReporter.ReportError2(details.Message,
                                                                    details.Code,
                                                                    details.Priority,
                                                                    details.LineNumberForErrorList,
                                                                    details.ColumnNumberForErrorList,
                                                                    details.EndLineNumberForErrorList,
                                                                    details.EndColumnNumberForErrorList,
                                                                    details.GetFileFullPath(_host));
                    handled = true;
                }
                catch (NotImplementedException)
                {   // Language Service doesn't handle it, typically because file
                    // isn't in the project or because it doesn't have line/column
                }
            }

            return(handled ? await HandledAndStopProcessing.ConfigureAwait(false) : await NotHandled.ConfigureAwait(false));
        }
        public async Task AddMessageAsync_UnrecognizedArgsAsTaskBuildEventArgs_ReturnsNotHandled()
        {
            var provider = CreateInstance();

            var task = new TargetGeneratedError("Test", new LazyFormattedBuildEventArgs("Message", "HelpKeyword", "SenderName"));

            var result = await provider.AddMessageAsync(task);

            Assert.Equal(AddMessageResult.NotHandled, result);
        }
        public async Task AddMessageAsync_WhenNoHostSpecificErrorReporter_ReturnsNotHandled()
        {
            var provider = CreateInstance();

            var task = new TargetGeneratedError("Test", new BuildErrorEventArgs(null, "Code", "File", 1, 1, 1, 1, "Message", "HelpKeyword", "Sender"));

            var result = await provider.AddMessageAsync(task);

            Assert.Equal(AddMessageResult.NotHandled, result);
        }
        public async Task AddMessageAsync_ArgsWithNoCodeAsTask_ReturnsNotHandled()
        {
            var provider = CreateInstance();

            var task = new TargetGeneratedError("Test", new BuildErrorEventArgs(null, "" /* Code */, "File", 1, 1, 1, 1, "Message", "HelpKeyword", "Sender"));

            var result = await provider.AddMessageAsync(task);

            Assert.Equal(AddMessageResult.NotHandled, result);
        }
        public async void AddMessageAsync_WhenNoProjectsWithIntellisense_ReturnsNotHandled()
        {
            var provider = CreateInstance();

            var task = new TargetGeneratedError("Test", new BuildErrorEventArgs(null, "Code", "File", 1, 1, 1, 1, "Message", "HelpKeyword", "Sender"));

            var result = await provider.AddMessageAsync(task);

            Assert.Equal(result, AddMessageResult.NotHandled);
        }
        public Task <AddMessageResult> AddMessageAsync(TargetGeneratedError error)
        {
            Requires.NotNull(error, nameof(error));

            return(AddMessageCoreAsync(error));
        }