public override void EnterRuleFactMatch(RuleFactMatchContext context)
{
var patternTypeName = context.type().GetText();
var patternType = _parserContext.GetType(patternTypeName);
var variableTypeName = context.local_variable_type().VAR() == null
? context.local_variable_type().type().GetText()
: patternTypeName;
var variableType = _parserContext.GetType(variableTypeName);
var id = context.identifier().GetText();
_parserContext.Scope.Declare(variableType, id);
var patternBuilder = _groupBuilder.Pattern(patternType, id);
if (context.expression_list() != null)
{
foreach (var expressionContext in context.expression_list().expression())
{
using (_parserContext.PushScope())
{
var expressionParser = new ExpressionParser(_parserContext, patternType);
var expression = (LambdaExpression)expressionParser.Visit(expressionContext);
patternBuilder.DslConditions(_groupBuilder.Declarations, expression);
}
}
}
}
public override Expression VisitUnary_expression(Unary_expressionContext context)
{
if (context.primary_expression() != null)
{
return(Visit(context.primary_expression()));
}
var expression = Visit(context.unary_expression());
if (context.type() != null)
{
var type = _parserContext.GetType(context.type().GetText());
return(Expression.Convert(expression, type));
}
var op = context.children[0].GetText();
if (op == "!" || op == "~")
{
expression = Expression.Not(expression);
}
else if (op == "+")
{
//Keep the expression
}
else if (op == "-")
{
expression = Expression.Negate(expression);
}
else
{
throw new CompilationException($"Unsupported operation. Operation={op}", context);
}
return(expression);
}
public void TypeName(string typeName)
{
_type = _parserContext.GetType(typeName);
_name = null;
}