Enhances the error message you get when you provide an invalid, simple breakpoint conditon message like $i == 3 or $i > 5.

Author: rkeithhill

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -133,6 +133,17 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                         {
                             ScriptBlock actionScriptBlock = ScriptBlock.Create(breakpoint.Condition);
 
+                            // Check for simple, common errors that ScriptBlock parsing will not catch 
+                            // e.g. $i == 3 and $i > 3
+                            string message;
+                            if (!ValidateBreakpointConditionAst(actionScriptBlock.Ast, out message))
+                            {
+                                breakpoint.Verified = false;
+                                breakpoint.Message = message;
+                                resultBreakpointDetails.Add(breakpoint);
+                                continue;
+                            }
+
                             // Check for "advanced" condition syntax i.e. if the user has specified
                             // a "break" or  "continue" statement anywhere in their scriptblock,
                             // pass their scriptblock through to the Action parameter as-is.
@@ -156,7 +167,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                             // Failed to create conditional breakpoint likely because the user provided an 
                             // invalid PowerShell expression. Let the user know why.
                             breakpoint.Verified = false;
-                            breakpoint.Message = ex.Message;
+                            breakpoint.Message = ExtractAndScrubParseExceptionMessage(ex, breakpoint.Condition);
                             resultBreakpointDetails.Add(breakpoint);
                             continue;
                         }
@@ -536,6 +547,85 @@ private async Task FetchStackFrames()
             }
         }
 
+        private bool ValidateBreakpointConditionAst(Ast conditionAst, out string message)
+        {
+            message = string.Empty;
+
+            // We are only inspecting a few simple scenarios in the EndBlock only.
+            ScriptBlockAst scriptBlockAst = conditionAst as ScriptBlockAst;
+            if ((scriptBlockAst != null) && 
+                (scriptBlockAst.BeginBlock == null) && 
+                (scriptBlockAst.ProcessBlock == null) && 
+                (scriptBlockAst.EndBlock != null) && 
+                (scriptBlockAst.EndBlock.Statements.Count == 1))
+            {
+                StatementAst statementAst = scriptBlockAst.EndBlock.Statements[0];
+                string condition = statementAst.Extent.Text;
+
+                if (statementAst is AssignmentStatementAst)
+                {
+                    message = FormatInvalidBreakpointConditionMessage(condition, "Use '-eq' instead of '=='.");
+                    return false;
+                }
+
+                PipelineAst pipelineAst = statementAst as PipelineAst;
+                if ((pipelineAst != null) && (pipelineAst.PipelineElements.Count == 1) &&
+                    (pipelineAst.PipelineElements[0].Redirections.Count > 0))
+                {
+                    message = FormatInvalidBreakpointConditionMessage(condition, "Use '-gt' instead of '>'.");
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private string ExtractAndScrubParseExceptionMessage(ParseException parseException, string condition)
+        {
+            string[] messageLines = parseException.Message.Split('\n');
+
+            // Skip first line - it is a location indicator "At line:1 char: 4"
+            for (int i = 1; i < messageLines.Length; i++)
+            {
+                string line = messageLines[i];
+                if (line.StartsWith("+"))
+                {
+                    continue;
+                }
+
+                if (!string.IsNullOrWhiteSpace(line))
+                {
+                    // Note '==' and '>" do not generate parse errors
+                    if (line.Contains("'!='"))
+                    {
+                        line += " Use operator '-ne' instead of '!='.";
+                    }
+                    else if (line.Contains("'<'") && condition.Contains("<="))
+                    {
+                        line += " Use operator '-le' instead of '<='.";
+                    }
+                    else if (line.Contains("'<'"))
+                    {
+                        line += " Use operator '-lt' instead of '<'.";
+                    }
+                    else if (condition.Contains(">="))
+                    {
+                        line += " Use operator '-ge' instead of '>='.";
+                    }
+
+                    return FormatInvalidBreakpointConditionMessage(condition, line);
+                }
+            }
+
+            // If the message format isn't in a form we expect, just return the whole message.
+            return FormatInvalidBreakpointConditionMessage(condition, parseException.Message);
+        }
+
+        private string FormatInvalidBreakpointConditionMessage(string condition, string message)
+        {
+            return $"'{condition}' is not a valid PowerShell expression. {message}";
+        }
+
         #endregion
 
         #region Events

test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs

@@ -279,6 +279,28 @@ await this.debugService.SetLineBreakpoints(
             Assert.Contains("Unexpected token '-ez'", breakpoints[1].Message);
         }
 
+        [Fact]
+        public async Task DebuggerFindsParseableButInvalidSimpleBreakpointConditions()
+        {
+            BreakpointDetails[] breakpoints =
+                await this.debugService.SetLineBreakpoints(
+                    this.debugScriptFile,
+                    new[] {
+                        BreakpointDetails.Create("", 5, column: null, condition: "$i == 100"),
+                        BreakpointDetails.Create("", 7, column: null, condition: "$i > 100")
+                    });
+
+            Assert.Equal(2, breakpoints.Length);
+            Assert.Equal(5, breakpoints[0].LineNumber);
+            Assert.False(breakpoints[0].Verified);
+            Assert.Contains("Use '-eq' instead of '=='", breakpoints[0].Message);
+
+            Assert.Equal(7, breakpoints[1].LineNumber);
+            Assert.False(breakpoints[1].Verified);
+            Assert.NotNull(breakpoints[1].Message);
+            Assert.Contains("Use '-gt' instead of '>'", breakpoints[1].Message);
+        }
+
         [Fact]
         public async Task DebuggerBreaksWhenRequested()
         {