Fix compilation issues (#60)

docs/parsers.md

@@ -619,7 +619,7 @@ Point { x: 1, y: 2}
 
 ### ElseError
 
-Fails parsing with a custom error message.
+Fails parsing with a custom error message when the inner parser didn't match.
 
 ```c#
 Parser<T> ElseError(string message)
@@ -645,12 +645,29 @@ failure: "Expected an integer at (1:3)
 
 ### Error
 
+Fails parsing with a custom error message when the inner parser matched.
+
 ```c#
 Parser<T> Error(string message)
 Parser<U> Error<U>(string message)
 ```
 
+Usage:
 
+```c#
+var parser = 
+ Terms.Char('a')
+ .Or(Terms.Char('b')
+ .Or(Terms.Char('c').Error("Unexpected char c")
+
+parser.Parse("1,");
+```
+
+Result:
+
+```
+failure: "Expected an integer at (1:3)
+```
 ### When
 
 Adds some additional logic for a parser to succeed.

src/Parlot/Fluent/Error.cs

@@ -37,32 +37,36 @@ public CompilationResult Compile(CompilationContext context)
  var value = context.DeclareValueVariable(result, Expression.Default(typeof(T)));
 
  // parse1 instructions
+ // success = true
  // 
- // if (!parser1.Success)
+ // if (parser1.Success)
+ // {
+ // value = parser1.Value
+ // }
+ // else
  // {
  // throw new ParseException(_message, context.Scanner.Cursor.Position);
  // }
- // 
- // value = parser1.Value
  //
 
  var parserCompileResult = _parser.Build(context, requireResult: true);
 
  var block = Expression.Block(
  parserCompileResult.Variables,
  parserCompileResult.Body
+ .Append(Expression.Assign(value, parserCompileResult.Value))
  .Append(
- Expression.IfThen(
- Expression.Not(parserCompileResult.Success),
+ Expression.IfThenElse(
+ parserCompileResult.Success,
+ context.DiscardResult
+ ? Expression.Empty()
+ : Expression.Assign(value, parserCompileResult.Value),
  context.ThrowParseException(Expression.Constant(_message))
- )
- ).Append(
- context.DiscardResult
- ? Expression.Empty()
- : Expression.Assign(value, parserCompileResult.Value)
- )
+
+
+ ))
  );
- 
+
  result.Body.Add(block);
 
  return result;
@@ -96,31 +100,27 @@ public CompilationResult Compile(CompilationContext context)
  {
  var result = new CompilationResult();
 
- _ = context.DeclareSuccessVariable(result, true);
- var value = context.DeclareValueVariable(result, Expression.Default(typeof(T)));
+ _ = context.DeclareSuccessVariable(result, false);
+ _ = context.DeclareValueVariable(result, Expression.Default(typeof(T)));
 
  // parse1 instructions
- // 
+ // success = false;
+ //
  // if (parser1.Success)
  // {
  // value = parser1.Value;
  // throw new ParseException(_message, context.Scanner.Cursor.Position);
  // }
 
- var parserCompileResult = _parser.Build(context, requireResult: true);
+ var parserCompileResult = _parser.Build(context, requireResult: false);
 
  var block = Expression.Block(
  parserCompileResult.Variables,
  parserCompileResult.Body
  .Append(
  Expression.IfThen(
  parserCompileResult.Success,
- Expression.Block(
- context.DiscardResult
- ? Expression.Empty()
- : Expression.Assign(value, parserCompileResult.Value),
- context.ThrowParseException(Expression.Constant(_message))
- )
+ context.ThrowParseException(Expression.Constant(_message))
  )
  )
  );
@@ -153,24 +153,25 @@ public override bool Parse(ParseContext context, ref ParseResult<U> result)
  throw new ParseException(_message, context.Scanner.Cursor.Position);
  }
 
- return true;
+ return false;
  }
 
  public CompilationResult Compile(CompilationContext context)
  {
  var result = new CompilationResult();
 
- _ = context.DeclareSuccessVariable(result, true);
+ _ = context.DeclareSuccessVariable(result, false);
  _ = context.DeclareValueVariable(result, Expression.Default(typeof(U)));
 
  // parse1 instructions
+ // success = false;
  // 
  // if (parser1.Success)
  // {
  // throw new ParseException(_message, context.Scanner.Cursor.Position);
  // }
 
- var parserCompileResult = _parser.Build(context, requireResult: true);
+ var parserCompileResult = _parser.Build(context, requireResult: false);
 
  var block = Expression.Block(
  parserCompileResult.Variables,

src/Parlot/Fluent/OneOf.cs

@@ -171,7 +171,7 @@ public CompilationResult Compile(CompilationContext context)
  var start = context.DeclarePositionVariable(result);
 
  block = Expression.Block(
- context.SkipWhiteSpace(),
+ context.ParserSkipWhiteSpace(),
  switchExpr,
  Expression.IfThen(
  Expression.IsFalse(success),

test/Parlot.Tests/CompileTests.cs

@@ -439,12 +439,25 @@ public void CompiledWhenShouldResetPositionWhenFalse()
  Assert.True(evenIntegers.TryParse("1235", out var result1));
  Assert.Equal(1235, result1.Item2);
  }
- 
+
  [Fact]
  public void ErrorShouldThrowIfParserSucceeds()
  {
  Assert.False(Literals.Char('a').Error("'a' was not expected").Compile().TryParse("a", out _, out var error));
  Assert.Equal("'a' was not expected", error.Message);
+
+ Assert.False(Literals.Char('a').Error<int>("'a' was not expected").Compile().TryParse("a", out _, out error));
+ Assert.Equal("'a' was not expected", error.Message);
+ }
+
+ [Fact]
+ public void ErrorShouldReturnFalseThrowIfParserFails()
+ {
+ Assert.False(Literals.Char('a').Error("'a' was not expected").Compile().TryParse("b", out _, out var error));
+ Assert.Null(error);
+
+ Assert.False(Literals.Char('a').Error<int>("'a' was not expected").Compile().TryParse("b", out _, out error));
+ Assert.Null(error);
  }
 
  [Fact]

test/Parlot.Tests/FluentTests.cs

@@ -514,15 +514,35 @@ public void ErrorShouldThrowIfParserSucceeds()
  {
  Assert.False(Literals.Char('a').Error("'a' was not expected").TryParse("a", out _, out var error));
  Assert.Equal("'a' was not expected", error.Message);
+
+ Assert.False(Literals.Char('a').Error<int>("'a' was not expected").TryParse("a", out _, out error));
+ Assert.Equal("'a' was not expected", error.Message);
  }
-
+
+ [Fact]
+ public void ErrorShouldReturnFalseThrowIfParserFails()
+ {
+ Assert.False(Literals.Char('a').Error("'a' was not expected").TryParse("b", out _, out var error));
+ Assert.Null(error);
+
+ Assert.False(Literals.Char('a').Error<int>("'a' was not expected").TryParse("b", out _, out error));
+ Assert.Null(error);
+ }
+
  [Fact]
  public void ErrorShouldThrow()
  {
  Assert.False(Literals.Char('a').Error("'a' was not expected").TryParse("a", out _, out var error));
  Assert.Equal("'a' was not expected", error.Message);
  }
-
+
+ [Fact]
+ public void ErrorShouldResetPosition()
+ {
+ Assert.False(Literals.Char('a').Error("'a' was not expected").TryParse("a", out _, out var error));
+ Assert.Equal("'a' was not expected", error.Message);
+ }
+
  [Fact]
  public void ElseErrorShouldThrowIfParserFails()
  {