void DesugarDeconstructorPatternCase(expression matchingExpression, pattern_case patternCase)
{
Debug.Assert(patternCase.pattern is deconstructor_pattern);
var isExpression = new is_pattern_expr(matchingExpression, patternCase.pattern);
var ifCondition = patternCase.condition == null ? (expression)isExpression : bin_expr.LogicalAnd(isExpression, patternCase.condition);
var ifCheck = SubtreeCreator.CreateIf(ifCondition, patternCase.case_action);
// Добавляем полученные statements в результат
AddDesugaredCaseToResult(ifCheck, ifCheck);
}
private void DefaultDesugarPattern(expression matchingExpression, pattern_case patternCase)
{
//var paramCheckExpr = DesugarDeconstructorPatternParameters(patternCase.pattern as deconstructor_pattern);
var isExpression = new is_pattern_expr(matchingExpression, patternCase.pattern, patternCase.source_context);
var ifCondition = patternCase.condition == null ? (expression)isExpression : bin_expr.LogicalAnd(isExpression, patternCase.condition);
var ifCheck = SubtreeCreator.CreateIf(ifCondition, patternCase.case_action);
// Добавляем полученные statements в результат
AddDesugaredCaseToResult(ifCheck, ifCheck);
}
public override void visit(is_pattern_expr isPatternExpr)
{
if (GetLocation(isPatternExpr) == PatternLocation.Unknown)
{
throw new SyntaxVisitorError("PATTERN_MATHING_IS_NOT_SUPPORTED_IN_THIS_CONTEXT", isPatternExpr.source_context);
}
Debug.Assert(GetAscendant <statement_list>(isPatternExpr) != null, "Couldn't find statement list in upper nodes");
DesugarIsExpression(isPatternExpr);
}
private void DesugarIsExpressionInAssignment(is_pattern_expr isExpression)
{
var pattern = isExpression.right as deconstructor_pattern;
var desugaringResult = DesugarPattern(pattern, isExpression.left);
ReplaceUsingParent(isExpression, desugaringResult.SuccessVariable);
var statementsToAdd = desugaringResult.GetDeconstructionDefinitions(pattern.source_context);
statementsToAdd.Add(desugaringResult.GetPatternCheckWithDeconstrunctorCall());
AddDefinitionsInUpperStatementList(isExpression, statementsToAdd);
}
private List <statement> ProcessDesugaringForCollectionPattern(is_pattern_expr isExpression)
{
var pattern = isExpression.right as collection_pattern;
var desugaringResult = DesugarCollectionPattern(pattern, isExpression.left);
ReplaceUsingParent(isExpression, desugaringResult.SuccessMatchingCheck);
var statementsToAdd = new List <statement>();
statementsToAdd.AddRange(desugaringResult.VarParametersDeclarations);
statementsToAdd.AddRange(desugaringResult.ElemTypeChecks);
return(statementsToAdd);
}
private List <statement> ProcessDesugaringForDeconstructorPattern(is_pattern_expr isExpression)
{
var pattern = isExpression.right as deconstructor_pattern;
var desugaringResult = DesugarDeconstructorPattern(pattern, isExpression.left);
ReplaceUsingParent(isExpression, desugaringResult.SuccessVariable);
var statementsToAdd = desugaringResult.GetDeconstructionDefinitions(pattern.source_context);
statementsToAdd.Add(GetMatchedExpressionCheck(isExpression.left));
statementsToAdd.Add(GetTypeCompatibilityCheck(isExpression));
statementsToAdd.Add(desugaringResult.GetPatternCheckWithDeconstrunctorCall());
return(statementsToAdd);
}
public override void visit(is_pattern_expr isPatternExpr)
{
var pp = isPatternExpr.right?.parameters;
if (pp != null)
{
foreach (var p in pp)
{
if (p is var_deconstructor_parameter vdp)
{
NamesInIsVars.Add(vdp.identifier.name.ToLower());
}
}
}
}
private void DesugarIsExpressionInIfCondition(is_pattern_expr isExpression)
{
List <statement> statementsToAdd = null;
switch (isExpression.right)
{
case deconstructor_pattern dp:
if (dp.const_params_check != null)
{
var ifToAddConstParamsCheckTo = GetAscendant <if_node>(isExpression);
ifToAddConstParamsCheckTo.condition = bin_expr.LogicalAnd(ifToAddConstParamsCheckTo.condition, dp.const_params_check);
}
statementsToAdd = ProcessDesugaringForDeconstructorPattern(isExpression);
break;
case collection_pattern cp:
statementsToAdd = ProcessDesugaringForCollectionPattern(isExpression);
break;
case tuple_pattern cp:
statementsToAdd = ProcessDesugaringForTuplePattern(isExpression);
break;
case const_pattern cp:
statementsToAdd = ProcessDesugaringForConstPattern(isExpression);
break;
}
var enclosingIf = GetAscendant <if_node>(isExpression);
// Если уже обрабатывался ранее (второй встретившийся в том же условии is), то не изменяем if
if (processedIfNodes.Contains(enclosingIf))
{
AddDefinitionsInUpperStatementList(isExpression, statementsToAdd);
}
// Иначе помещаем определения и if-then в отдельный блок, а else после этого блока
else
{
// Сохраняем родителя, так как он поменяется при вызове ConvertIfNode
var ifParent = enclosingIf.Parent;
statement elseBody;
var convertedIf = ConvertIfNode(enclosingIf, statementsToAdd, out elseBody);
ifParent.ReplaceDescendantUnsafe(enclosingIf, convertedIf);
convertedIf.Parent = ifParent;
elseBody?.visit(this);
}
}
public override void visit(is_pattern_expr isPatternExpr)
{
var pp = isPatternExpr.right?.parameters;
if (pp != null)
{
foreach (var p in pp)
{
if (p is var_deconstructor_parameter vdp)
{
var newname = GenerateNewName(vdp.identifier.name);
AddNameNewName(vdp.identifier.TypedClone(), newname);
vdp.identifier.name = newname;
}
}
}
}
private expression DesugarRecursiveDeconstructor(expression expression, deconstructor_pattern pattern)
{
List <pattern_deconstructor_parameter> parameters = pattern.parameters;
expression conjunction = new is_pattern_expr(expression, pattern);
for (int i = 0; i < parameters.Count; i++)
{
if (parameters[i] is recursive_deconstructor_parameter parameter)
{
//var parameterType = (parameter.pattern as deconstructor_pattern).type;
var newName = NewGeneralName();
var varParameter = new var_deconstructor_parameter(newName, null);
parameters[i] = varParameter;
varParameter.Parent = parameters[i];
conjunction = bin_expr.LogicalAnd(conjunction, DesugarRecursiveDeconstructor(newName, parameter.pattern as deconstructor_pattern));
}
}
return(conjunction);
}
private void DesugarIsExpression(is_pattern_expr isPatternExpr)
{
Debug.Assert(isPatternExpr.right is deconstructor_pattern);
var patternLocation = GetLocation(isPatternExpr);
var pattern = isPatternExpr.right as deconstructor_pattern;
if (pattern.IsRecursive)
{
var desugaredRecursiveIs = DesugarRecursiveDeconstructor(isPatternExpr.left, pattern);
ReplaceUsingParent(isPatternExpr, desugaredRecursiveIs);
desugaredRecursiveIs.visit(this);
return;
}
switch (patternLocation)
{
case PatternLocation.IfCondition: DesugarIsExpressionInIfCondition(isPatternExpr); break;
case PatternLocation.Assign: DesugarIsExpressionInAssignment(isPatternExpr); break;
}
}
private void DesugarIsExpression(is_pattern_expr isPatternExpr)
{
if (isPatternExpr.right.IsRecursive)
{
var desugaredRecursiveIs = DesugarRecursiveParameters(isPatternExpr.left, isPatternExpr.right);
ReplaceUsingParent(isPatternExpr, desugaredRecursiveIs);
desugaredRecursiveIs.visit(this);
return;
}
var patternLocation = GetLocation(isPatternExpr);
if (isPatternExpr.right is deconstructor_pattern pattern)
{
var constParamCheck = DesugarDeconstructorPatternParameters(isPatternExpr.right as deconstructor_pattern);
pattern.const_params_check = constParamCheck;
}
//AddDefinitionsInUpperStatementList(isPatternExpr, new[] { GetTypeCompatibilityCheck(isPatternExpr) });
switch (patternLocation)
{
case PatternLocation.IfCondition: DesugarIsExpressionInIfCondition(isPatternExpr); break;
case PatternLocation.Assign: DesugarIsExpressionInAssignment(isPatternExpr); break;
}
}
private semantic_check_sugared_statement_node GetTypeCompatibilityCheck(is_pattern_expr expression) =>
new semantic_check_sugared_statement_node(SemanticCheckType.MatchedExpressionAndType, new List <syntax_tree_node>()
{
expression.left, (expression.right as deconstructor_pattern).type
});
public virtual void visit(is_pattern_expr _is_pattern_expr)
{
DefaultVisit(_is_pattern_expr);
}
