319 lines
15 KiB
C#
319 lines
15 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using PascalABCCompiler.SyntaxTree;
|
||
using PascalABCCompiler.TreeRealization;
|
||
|
||
namespace PascalABCCompiler.TreeConverter
|
||
{
|
||
// Patterns
|
||
public partial class syntax_tree_visitor
|
||
{
|
||
public override void visit(desugared_deconstruction deconstruction)
|
||
{
|
||
var invokationTarget = convert_strong(deconstruction.deconstruction_target as expression);
|
||
var types = InferAndCheckPatternVariableTypes(deconstruction.variables.definitions, invokationTarget, deconstruction);
|
||
if (types == null)
|
||
return;
|
||
|
||
foreach (var definition in deconstruction.WithTypes(types.Select(x => new semantic_type_node(x)).ToArray()))
|
||
definition.visit(this);
|
||
}
|
||
|
||
private type_node[] InferAndCheckPatternVariableTypes(List<var_def_statement> variableDefinitions, expression_node patternInstance, desugared_deconstruction deconstruction)
|
||
{
|
||
if (patternInstance.type.IsPointer)
|
||
{
|
||
AddError(get_location(deconstruction), "PATTERN_MATCHING_DOESNT_SUPPORT_POINTERS");
|
||
return null;
|
||
}
|
||
var parameterTypes = variableDefinitions.Select(x => x.vars_type == null ? null : convert_strong(x.vars_type)).ToArray();
|
||
List<function_node> candidates = new List<function_node>();
|
||
List<type_node[]> deducedParametersList = new List<type_node[]>();
|
||
var allDeconstructs = patternInstance.type.find_in_type(compiler_string_consts.deconstruct_method_name, context.CurrentScope);
|
||
if (allDeconstructs == null)
|
||
{
|
||
AddError(get_location(deconstruction), "NO_DECONSTRUCT_FOUND");
|
||
return null;
|
||
}
|
||
|
||
foreach (var canditateSymbol in allDeconstructs)
|
||
{
|
||
var deducedParameters = new type_node[parameterTypes.Length];
|
||
var possibleCandidate = canditateSymbol.sym_info as function_node;
|
||
if (!IsSuitableFunction(possibleCandidate, parameterTypes, patternInstance, get_location(deconstruction), out deducedParameters))
|
||
continue;
|
||
|
||
deducedParametersList.Add(deducedParameters);
|
||
candidates.Add(possibleCandidate);
|
||
}
|
||
|
||
if (candidates.Count == 0)
|
||
{
|
||
AddError(get_location(deconstruction), "NO_SUITABLE_DECONSTRUCT_FOUND");
|
||
return null;
|
||
}
|
||
else
|
||
if (candidates.Count > 1)
|
||
{
|
||
RemoveDefaultDeconstruct(candidates);
|
||
if (candidates.Count > 1 && !CheckIfParameterListElementsAreTheSame(deducedParametersList))
|
||
{
|
||
AddError(get_location(deconstruction), "DECONSTRUCTOR_METHOD_AMBIGUITY");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// Единственный подхдящий кандидат найден, либо их несколько, с одинаковыми выходными параметрами
|
||
var chosenFunction = candidates.First();
|
||
if (chosenFunction.is_extension_method)
|
||
{
|
||
if (chosenFunction.is_generic_function)
|
||
chosenFunction = generic_convertions.get_function_instance(chosenFunction, deducedParametersList.First().ToList());
|
||
|
||
return chosenFunction.parameters.Where(x => !IsSelfParameter(x)).Select(x => x.type).ToArray();
|
||
}
|
||
else
|
||
return chosenFunction.parameters.Select(x => x.type).ToArray();//deducedParametersList[0];
|
||
}
|
||
|
||
/// <summary>
|
||
/// Проверяет, подходит ли функция для вызова с указанными параметрами
|
||
/// </summary>
|
||
/// <param name="candidate"></param>
|
||
/// <param name="givenParameterTypes">Типы параметров, указанные пользователем</param>
|
||
/// <returns></returns>
|
||
private bool IsSuitableFunction(
|
||
function_node candidate,
|
||
type_node[] givenParameterTypes,
|
||
expression_node patternInstance,
|
||
location deconstructionLocation,
|
||
out type_node[] parameterTypes)
|
||
{
|
||
parameterTypes = new type_node[givenParameterTypes.Length];
|
||
candidate.parameters[0].name = "Self"; // SSM 23.06.20 #2268 - это если в NET где-то такое нашли
|
||
var selfParameter = candidate.is_extension_method ? candidate.parameters.FirstOrDefault(IsSelfParameter) : null;
|
||
Debug.Assert(!candidate.is_extension_method || selfParameter != null, "Couldn't find self parameter in extension method");
|
||
var candidateParameterTypes =
|
||
candidate.is_extension_method ?
|
||
candidate.parameters.Where(x => !IsSelfParameter(x)).ToArray() :
|
||
candidate.parameters.ToArray();
|
||
|
||
if (candidateParameterTypes.Length != givenParameterTypes.Length)
|
||
return false;
|
||
|
||
// Разрешаем только deconstruct текущего класса, родительские в расчет не берем
|
||
if (candidate is common_method_node commonMethod && !AreTheSameType(patternInstance.type, commonMethod.cont_type))
|
||
return false;
|
||
|
||
var genericDeduceNeeded = candidate.is_extension_method && candidate.is_generic_function;
|
||
type_node[] deducedGenerics = new type_node[candidate.generic_parameters_count];
|
||
if (genericDeduceNeeded)
|
||
{
|
||
// Выводим дженерики по self
|
||
var nils = new List<int>();
|
||
var deduceSucceded = generic_convertions.DeduceInstanceTypes(selfParameter.type, patternInstance.type, deducedGenerics, nils, candidate.get_generic_params_list());
|
||
if (!deduceSucceded || deducedGenerics.Contains(null))
|
||
return false;
|
||
}
|
||
|
||
for (int i = 0; i < givenParameterTypes.Length; i++)
|
||
{
|
||
var givenParameter = givenParameterTypes[i];
|
||
var candidateParameter = candidateParameterTypes[i].type;
|
||
if (genericDeduceNeeded && (candidateParameter.is_generic_parameter || candidateParameter.is_generic_type_instance))
|
||
candidateParameter = InstantiateParameter(candidateParameter, deducedGenerics);
|
||
|
||
if (givenParameter != null && !AreTheSameType(candidateParameter, givenParameter)
|
||
&& !(candidateParameter != null && givenParameter != null && candidateParameter.is_generic_parameter
|
||
&& givenParameter.is_generic_parameter && candidateParameter.name == givenParameter.name && givenParameter.base_type == candidateParameter.base_type))
|
||
return false;
|
||
|
||
parameterTypes[i] = candidateParameter;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private type_node GetDeconstructorOwner(function_node deconstructor)
|
||
{
|
||
switch (deconstructor)
|
||
{
|
||
case common_method_node commonMethod: return commonMethod.cont_type;
|
||
case common_namespace_function_node commonNamespaseFunction: return GetSelfParameter(commonNamespaseFunction).type;
|
||
default: return null;
|
||
}
|
||
}
|
||
|
||
private bool AreTheSameType(type_node type1, type_node type2) =>
|
||
type1 != null &&
|
||
type2 != null &&
|
||
convertion_data_and_alghoritms.possible_equal_types(type1, type2);
|
||
|
||
private bool IsSelfParameter(parameter parameter) => parameter.name.ToLower() == compiler_string_consts.self_word;
|
||
|
||
private void RemoveDefaultDeconstruct(List<function_node> candidates)
|
||
{
|
||
var index = candidates.FindIndex(IsDefaultDeconstruct);
|
||
if (index >= 0)
|
||
candidates.RemoveAt(index);
|
||
}
|
||
|
||
private bool IsDefaultDeconstruct(function_node function)
|
||
{
|
||
// TODO Patterns: check if it declared in PABCSystem
|
||
return
|
||
function.generic_parameters_count == 1 &&
|
||
function.parameters.Count == 2 &&
|
||
function.parameters[0].type.is_generic_parameter &&
|
||
function.parameters[1].type.is_generic_parameter &&
|
||
AreTheSameType(function.parameters[0].type, function.parameters[1].type);
|
||
}
|
||
|
||
private bool CheckIfParameterListElementsAreTheSame(List<type_node[]> parametersList)
|
||
{
|
||
var first = parametersList.First();
|
||
for (int i = 1; i < parametersList.Count; i++)
|
||
{
|
||
if (first.Length != parametersList[i].Length)
|
||
return false;
|
||
|
||
for (int j = 0; j < first.Length; j++)
|
||
if (!AreTheSameType(first[j], parametersList[i][j]))
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private type_node InstantiateParameter(SemanticTree.ITypeNode genericType, type_node[] instances)
|
||
{
|
||
if (genericType.is_generic_parameter)
|
||
return instances[(genericType as type_node).generic_param_index];
|
||
else
|
||
{
|
||
var genericNode = (genericType as generic_instance_type_node);
|
||
if (genericNode != null)
|
||
{
|
||
var parameters = genericNode.instance_params.Select(x => InstantiateParameter(x, instances)).ToList();
|
||
genericNode.instance_params = parameters;
|
||
}
|
||
|
||
return genericNode as type_node;
|
||
}
|
||
}
|
||
|
||
private IEnumerable<int> GenericParameterIndices(SemanticTree.ITypeNode node)
|
||
{
|
||
if (node.is_generic_parameter)
|
||
yield return (node as type_node).generic_param_index;
|
||
|
||
if (node is generic_instance_type_node genericNode)
|
||
foreach (var index in genericNode.instance_params.Aggregate(
|
||
Enumerable.Empty<int>(),
|
||
(indices, nextNode) => indices.Concat(GenericParameterIndices(nextNode)))
|
||
.Distinct())
|
||
yield return index;
|
||
|
||
yield break;
|
||
}
|
||
|
||
private parameter GetSelfParameter(function_node node) => node.parameters.FirstOrDefault(x => IsSelfParameter(x));
|
||
|
||
/// <summary>
|
||
/// Проводит проверки, общие для экземплярных деконструкторов и расширений
|
||
/// </summary>
|
||
/// <param name="deconstructor"></param>
|
||
private void ExecuteCommonChecks(common_function_node deconstructor)
|
||
{
|
||
var dd = deconstructor as common_method_node;
|
||
if (dd != null && dd.IsStatic)
|
||
AddError(deconstructor.loc, "DECONSTRUCTOR_SHOULD_NOT_BE_STATIC");
|
||
if (deconstructor.return_value_type != null)
|
||
AddError(deconstructor.loc, "DECONSTRUCTOR_SHOULD_BE_A_PROCEDURE");
|
||
|
||
foreach (var parameter in deconstructor.parameters.Where(x => !IsSelfParameter(x)))
|
||
if (parameter.parameter_type != SemanticTree.parameter_type.var && parameter is common_parameter p)
|
||
AddError(p.loc, "DECONSTRUCTION_PARAMETERS_SHOULD_HAVE_VAR_MODIFIER");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Проверяет выражение, сопоставляемое с образцом
|
||
/// </summary>
|
||
/// <param name="matchedExpression"></param>
|
||
private void CheckMatchedExpression(expression matchedExpression)
|
||
{
|
||
var convertedExpression = convert_strong(matchedExpression);
|
||
if (convertedExpression.type.IsPointer)
|
||
AddError(get_location(matchedExpression), "PATTERN_MATCHING_DOESNT_SUPPORT_POINTERS");
|
||
}
|
||
|
||
private void CheckIfCanBeMatched(expression matchedExpression, type_definition targetType)
|
||
{
|
||
var type = convert_strong(targetType);
|
||
var expression = convert_strong(matchedExpression);
|
||
if (expression is typed_expression)
|
||
try_convert_typed_expression_to_function_call(ref expression);
|
||
|
||
var expressionType = expression.type;
|
||
if (type_table.is_derived(type, expressionType) ||
|
||
type_table.is_derived(expressionType, type) ||
|
||
AreTheSameType(type, expressionType) ||
|
||
type.IsInterface ||
|
||
expressionType.IsInterface || type.is_generic_parameter || expressionType.is_generic_parameter)
|
||
return;
|
||
|
||
AddError(get_location(matchedExpression), "EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expressionType.name, type.name);
|
||
}
|
||
|
||
private void CheckIfCanBeMatched(expression matchedExpression, expression patternExpression)
|
||
{
|
||
var patternNode = convert_strong(patternExpression);
|
||
var patternType = patternNode.type;
|
||
var expressionNode = convert_strong(matchedExpression);
|
||
if (expressionNode is typed_expression)
|
||
try_convert_typed_expression_to_function_call(ref expressionNode);
|
||
var expressionType = expressionNode.type;
|
||
|
||
if (!(patternNode is constant_node))
|
||
{
|
||
AddError(get_location(patternExpression), "MATCHING_WITH_NON_CONST");
|
||
}
|
||
|
||
var possible_convertion = type_table.get_convertions(patternType, expressionType);
|
||
var expressionTypeName = expressionType.BaseFullName;
|
||
var patternTypeName = patternType.BaseFullName;
|
||
var tupleName = "System.Tuple";
|
||
if (type_table.is_derived(patternType, expressionType) ||
|
||
type_table.is_derived(expressionType, patternType) ||
|
||
possible_convertion.first != null ||
|
||
AreTheSameType(patternType, expressionType) ||
|
||
(expressionTypeName.StartsWith(tupleName) &&
|
||
patternTypeName.StartsWith(tupleName) &&
|
||
int.Parse(expressionTypeName.Substring(tupleName.Length + 1, 1)) ==
|
||
int.Parse(patternTypeName.Substring(tupleName.Length + 1, 1))) ||
|
||
(expressionType.IsPointer && patternNode is null_const_node) ||
|
||
(patternType.IsPointer && expressionNode is null_const_node))
|
||
return;
|
||
|
||
AddError(get_location(matchedExpression), "EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expressionType.name, patternType.name);
|
||
}
|
||
|
||
private void CheckIfCanBeMatched(expression tuple, int32_const length)
|
||
{
|
||
var expressionType = convert_strong(tuple).type;
|
||
var expressionTypeName = expressionType.BaseFullName;
|
||
|
||
var tupleName = "System.Tuple";
|
||
if (expressionTypeName.StartsWith(tupleName) &&
|
||
int.Parse(expressionTypeName.Substring(tupleName.Length + 1, 1)) == length.val)
|
||
return;
|
||
|
||
AddError(get_location(tuple),
|
||
"EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expressionType.name, "Tuple`" + length.val);
|
||
}
|
||
}
|
||
}
|