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); }