227 lines
10 KiB
C#
227 lines
10 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)
|
||
{
|
||
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);
|
||
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];
|
||
var selfParameter = candidate.is_extension_method ? candidate.parameters.First(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);
|
||
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))
|
||
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)
|
||
{
|
||
if (deconstructor.return_value_type != null)
|
||
AddError(deconstructor.loc, "DECONSTRUCTOR_SOULD_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");
|
||
}
|
||
}
|
||
}
|