use of org.finos.legend.pure.m3.tools.matcher.Matcher in project legend-pure by finos.
the class TypeInference method processParamTypesOfLambdaUsedAsAFunctionExpressionParamValue.
public static boolean processParamTypesOfLambdaUsedAsAFunctionExpressionParamValue(ValueSpecification instanceValueContainer, LambdaFunction<?> lambdaFunction, VariableExpression templateToMatchLambdaTo, Matcher matcher, ProcessorState state, ModelRepository repository, ProcessorSupport processorSupport) throws PureCompilationException {
GenericType templateGenericType = templateToMatchLambdaTo._genericType();
Type templateFunctionType = templateGenericType._typeArguments().notEmpty() ? (Type) ImportStub.withImportStubByPass(templateGenericType._typeArguments().getFirst()._rawTypeCoreInstance(), processorSupport) : null;
FunctionType lambdaFunctionType = (FunctionType) ImportStub.withImportStubByPass(lambdaFunction._classifierGenericType()._typeArguments().getFirst()._rawTypeCoreInstance(), processorSupport);
if (org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(templateGenericType) && org.finos.legend.pure.m3.navigation.type.Type.subTypeOf(ImportStub.withImportStubByPass(templateGenericType._rawTypeCoreInstance(), processorSupport), processorSupport.package_getByUserPath(M3Paths.Function), processorSupport)) {
ListIterable<? extends VariableExpression> parameters = ListHelper.wrapListIterable(lambdaFunctionType._parameters());
for (int j = 0; j < parameters.size(); j++) {
VariableExpression param = parameters.get(j);
if (param._genericType() == null) {
if (org.finos.legend.pure.m3.navigation.type.Type.isBottomType(templateFunctionType, processorSupport) || org.finos.legend.pure.m3.navigation.type.Type.isTopType(templateFunctionType, processorSupport)) {
throw new PureCompilationException(lambdaFunction.getSourceInformation(), "Can't infer the parameters' types for the lambda. Please specify it in the signature.");
}
VariableExpression templateParam = ListHelper.wrapListIterable(((FunctionType) Objects.requireNonNull(templateFunctionType))._parameters()).get(j);
CoreInstance genericType = org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(templateParam._genericType(), state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
if (state.getTypeInferenceContext().isTypeParameterResolved(genericType)) {
genericType = state.getTypeInferenceContext().resolve(genericType);
} else {
return true;
}
CoreInstance multiplicity = org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.makeMultiplicityAsConcreteAsPossible(templateParam._multiplicity(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity());
param._genericType((GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.copyGenericTypeAsInferredGenericType(genericType, param.getSourceInformation(), processorSupport));
param._multiplicity((Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.copyMultiplicity(multiplicity, param.getSourceInformation(), processorSupport));
}
}
state.pushVariableContext();
FunctionDefinitionProcessor.process(lambdaFunction, state, matcher, repository);
LambdaFunctionProcessor.process(lambdaFunction, state, matcher, repository);
state.popVariableContext();
} else {
throw new PureCompilationException(lambdaFunction.getSourceInformation(), "Can't infer the parameters' types for the lambda. Please specify it in the signature.");
}
instanceValueContainer._genericTypeRemove();
InstanceValueProcessor.updateInstanceValue(instanceValueContainer, processorSupport);
return false;
}
use of org.finos.legend.pure.m3.tools.matcher.Matcher in project legend-pure by finos.
the class AssociationProcessor method process.
@Override
public void process(Association association, ProcessorState state, Matcher matcher, ModelRepository repository, Context context, ProcessorSupport processorSupport) {
RichIterable<? extends AbstractProperty> properties = association._properties();
RichIterable<? extends AbstractProperty> originalMilestonedProperties = association._originalMilestonedProperties();
RichIterable<? extends AbstractProperty> qualifiedProperties = association._qualifiedProperties();
for (AbstractProperty property : LazyIterate.concatenate((Iterable<AbstractProperty>) properties, (Iterable<AbstractProperty>) qualifiedProperties).concatenate((Iterable<AbstractProperty>) originalMilestonedProperties)) {
PostProcessor.processElement(matcher, property, state, processorSupport);
}
}
use of org.finos.legend.pure.m3.tools.matcher.Matcher in project legend-pure by finos.
the class FunctionDefinitionProcessor method processExpression.
private static void processExpression(FunctionDefinition<?> functionDefinition, Matcher matcher, ProcessorState processorState, ProcessorSupport processorSupport, int i, ValueSpecification expression) {
processorState.resetVariables();
PostProcessor.processElement(matcher, expression, processorState, processorSupport);
if (expression._usageContext() == null) {
ExpressionSequenceValueSpecificationContext usageContext = (ExpressionSequenceValueSpecificationContext) processorSupport.newAnonymousCoreInstance(null, M3Paths.ExpressionSequenceValueSpecificationContext);
usageContext._offset(i);
usageContext._functionDefinition(functionDefinition);
expression._usageContext(usageContext);
}
}
use of org.finos.legend.pure.m3.tools.matcher.Matcher in project legend-pure by finos.
the class FunctionExpressionProcessor method firstPassTypeInference.
private boolean firstPassTypeInference(FunctionExpression functionExpression, ListIterable<? extends ValueSpecification> parametersValues, ProcessorState processorState, Matcher matcher, ModelRepository repository, Context context, ProcessorSupport processorSupport) throws PureCompilationException {
TypeInferenceObserver observer = processorState.getObserver();
int i = 0;
observer.startProcessingFunctionExpression(functionExpression);
boolean inferenceSuccess = true;
observer.shiftTab();
observer.startFirstPassParametersProcessing();
observer.shiftTab();
observer.shiftTab();
org.eclipse.collections.api.block.function.Function<CoreInstance, Void> processElement = coreInstance -> {
PostProcessor.processElement(matcher, coreInstance, processorState, processorSupport);
return null;
};
for (ValueSpecification boundVariable : parametersValues) {
observer.processingParameter(functionExpression, i, boundVariable);
observer.shiftTab();
MilestoningDatesPropagationFunctions.possiblyExecuteInNewMilestoningDateContext(functionExpression, boundVariable, processElement, processorState, repository, context, processorSupport);
boolean success = this.isInferenceSuccess(boundVariable, processorSupport);
observer.inferenceResult(success);
inferenceSuccess = inferenceSuccess && success;
addTraceForParameterValue(functionExpression, i, boundVariable, processorSupport);
i++;
observer.unShiftTab();
}
observer.unShiftTab();
observer.unShiftTab();
return inferenceSuccess;
}
use of org.finos.legend.pure.m3.tools.matcher.Matcher in project legend-pure by finos.
the class FunctionExpressionProcessor method process.
@Override
public void process(FunctionExpression functionExpression, final ProcessorState state, final Matcher matcher, final ModelRepository repository, final Context context, final ProcessorSupport processorSupport) {
TypeInferenceObserver observer = state.getObserver();
state.pushTypeInferenceContext();
ListIterable<? extends ValueSpecification> parametersValues = ListHelper.wrapListIterable(functionExpression._parametersValues());
// Process the function's parameters (FIRST PASS)
boolean inferenceSuccess = firstPassTypeInference(functionExpression, parametersValues, state, matcher, repository, context, processorSupport);
// Function matching
ListIterable<? extends Function<?>> foundFunctions = null != functionExpression._funcCoreInstance() ? Lists.immutable.with((Function<?>) ImportStub.withImportStubByPass(functionExpression._funcCoreInstance(), processorSupport)) : Lists.immutable.empty();
String functionName = null;
if (foundFunctions.isEmpty()) {
// Check if the function is a property
InstanceValue propertyNameInstanceVal = functionExpression._propertyName();
if (null != propertyNameInstanceVal) {
ValueSpecification source = parametersValues.get(0);
String propertyName = ImportStub.withImportStubByPass(propertyNameInstanceVal._valuesCoreInstance().toList().get(0), processorSupport).getName();
GenericType sourceGenericType = extractAndValidateGenericType(processorSupport, propertyName, source);
// Is it an enum?
if (org.finos.legend.pure.m3.navigation.generictype.GenericType.subTypeOf(sourceGenericType, org.finos.legend.pure.m3.navigation.type.Type.wrapGenericType(processorSupport.package_getByUserPath(M3Paths.Enumeration), processorSupport), processorSupport)) {
reprocessEnumValueInExtractEnumValue(functionExpression, propertyName, state, repository, processorSupport);
} else {
Multiplicity sourceMultiplicity = source._multiplicity();
if (org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.isToOne(sourceMultiplicity, true)) {
AbstractProperty<?> propertyFunc = findFunctionForPropertyBasedOnMultiplicity(functionExpression, sourceGenericType, state, processorSupport, matcher);
if (null != propertyFunc) {
if (MilestoningFunctions.isGeneratedMilestonedQualifiedPropertyWithMissingDates(propertyFunc, processorSupport)) {
propertyFunc = (AbstractProperty<?>) MilestoningDatesPropagationFunctions.getMilestoningQualifiedPropertyWithAllDatesSupplied(functionExpression, state, repository, context, processorSupport, propertyNameInstanceVal, source, propertyName, propertyFunc);
}
foundFunctions = Lists.immutable.with(propertyFunc);
}
} else {
// Automap
reprocessPropertyForManySources(functionExpression, parametersValues, M3Properties.propertyName, sourceGenericType, repository, processorSupport);
// The parameters values are now different, so update
parametersValues = functionExpression._parametersValues().toList();
// Have another go at type inference
inferenceSuccess = firstPassTypeInference(functionExpression, parametersValues, state, matcher, repository, context, processorSupport);
// return;
}
}
} else // Check if the function is a qualifiedProperty
{
InstanceValue qualifiedPropertyNameVal = functionExpression._qualifiedPropertyName();
if (null != qualifiedPropertyNameVal) {
ValueSpecification source = parametersValues.get(0);
String qualifiedPropertyName = ImportStub.withImportStubByPass(qualifiedPropertyNameVal._valuesCoreInstance().toList().get(0), processorSupport).getName();
GenericType sourceGenericType = extractAndValidateGenericType(processorSupport, qualifiedPropertyName, source);
Multiplicity sourceMultiplicity = source._multiplicity();
// }
if (org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.isToOne(sourceMultiplicity, true)) {
ListIterable<QualifiedProperty<?>> qualifiedPropertyFuncs = findFunctionsForQualifiedPropertyBasedOnMultiplicity(functionExpression, sourceGenericType, parametersValues, processorSupport, matcher, state);
if (qualifiedPropertyFuncs.size() == 1 && MilestoningFunctions.isGeneratedMilestonedQualifiedPropertyWithMissingDates(qualifiedPropertyFuncs.getFirst(), processorSupport)) {
Function<?> mqp = (Function<?>) MilestoningDatesPropagationFunctions.getMilestoningQualifiedPropertyWithAllDatesSupplied(functionExpression, state, repository, context, processorSupport, qualifiedPropertyNameVal, source, qualifiedPropertyName, qualifiedPropertyFuncs.getFirst());
foundFunctions = Lists.immutable.with(mqp);
} else {
foundFunctions = qualifiedPropertyFuncs;
}
} else {
// Automap
reprocessPropertyForManySources(functionExpression, parametersValues, M3Properties.qualifiedPropertyName, sourceGenericType, repository, processorSupport);
// The parameters values are now different, so update
parametersValues = functionExpression._parametersValues().toList();
// Have another go at type inference
inferenceSuccess = firstPassTypeInference(functionExpression, parametersValues, state, matcher, repository, context, processorSupport);
}
}
}
if (foundFunctions.isEmpty()) {
// Match the functionExpression with the Function library (may still need to do it even if the function is a property because it may have been reprocessed as a Collect!)
foundFunctions = FunctionExpressionMatcher.findMatchingFunctionsInTheRepository(functionExpression, true, processorSupport);
functionName = getFunctionName(functionExpression);
}
}
Function<?> finalFunction = null;
boolean someInferenceFailed = false;
for (Function<?> foundFunction : foundFunctions) {
functionExpression._funcRemove();
functionExpression._funcCoreInstance(foundFunction);
state.getTypeInferenceContext().setScope(foundFunction);
FunctionType foundFunctionType = (FunctionType) processorSupport.function_getFunctionType(foundFunction);
observer.functionMatched(foundFunction, foundFunctionType);
// SECOND PASS
ListIterable<? extends VariableExpression> paramsType = foundFunctionType._parameters().toList();
// enumValues, autoMaps, etc...
parametersValues = functionExpression._parametersValues().toList();
boolean success = true;
if (!inferenceSuccess) {
observer.firstPassInferenceFailed();
observer.shiftTab();
observer.shiftTab();
observer.matchTypeParamsFromFoundFunction(foundFunction);
observer.shiftTab();
for (int z = 0; z < parametersValues.size(); z++) {
ValueSpecification instance = parametersValues.get(z);
if (isInferenceSuccess(instance, processorSupport)) {
observer.matchParam(z);
GenericType templateGenType = paramsType.get(z)._genericType();
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.register(templateGenType, instance._genericType(), typeInferenceContext.getTopContext(), observer);
typeInferenceContext.registerMul(paramsType.get(z)._multiplicity(), instance._multiplicity(), typeInferenceContext.getTopContext(), observer);
} else {
observer.paramInferenceFailed(z);
}
}
observer.unShiftTab();
observer.reverseMatching();
for (int z = 0; z < parametersValues.size(); z++) {
final ValueSpecification instance = parametersValues.get(z);
observer.processingParameter(functionExpression, z, instance);
GenericType templateGenType = paramsType.get(z)._genericType();
Multiplicity templateMultiplicity = paramsType.get(z)._multiplicity();
GenericType resolvedGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(templateGenType, state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
Multiplicity resolvedMultiplicity = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.makeMultiplicityAsConcreteAsPossible(templateMultiplicity, state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity());
if (isLambdaWithEmptyParamType(instance, processorSupport)) {
observer.shiftTab();
final VariableExpression templateToMatchLambdaTo = Objects.requireNonNull(getRawTypeFromGenericType(foundFunction, processorSupport))._parameters().toList().get(z);
observer.register(templateToMatchLambdaTo, templateToMatchLambdaTo, state.getTypeInferenceContext(), state.getTypeInferenceContext());
for (final CoreInstance val : ((InstanceValue) instance)._valuesCoreInstance()) {
if (val instanceof LambdaFunction) {
org.eclipse.collections.api.block.function.Function<CoreInstance, Boolean> processParamTypesOfLambdaUsedAsAFunctionExpressionParamValue = coreInstance -> !TypeInference.processParamTypesOfLambdaUsedAsAFunctionExpressionParamValue(instance, (LambdaFunction<?>) val, templateToMatchLambdaTo, matcher, state, repository, processorSupport);
success = success && MilestoningDatesPropagationFunctions.possiblyExecuteInNewMilestoningDateContext(functionExpression, val, processParamTypesOfLambdaUsedAsAFunctionExpressionParamValue, state, repository, context, processorSupport);
// Manage return type in any case
GenericType templateGenericType = templateToMatchLambdaTo._genericType();
ClassInstance functionClass = (ClassInstance) processorSupport.package_getByUserPath(M3Paths.Function);
if (org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(templateGenericType, processorSupport) && org.finos.legend.pure.m3.navigation.type.Type.subTypeOf(ImportStub.withImportStubByPass(templateGenericType._rawTypeCoreInstance(), processorSupport), functionClass, processorSupport)) {
GenericType templateGenFunctionType = templateGenericType._typeArguments().toList().get(0);
if (org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(templateGenFunctionType, processorSupport) && !org.finos.legend.pure.m3.navigation.type.Type.isTopType(Instance.getValueForMetaPropertyToOneResolved(templateGenFunctionType, M3Properties.rawType, processorSupport), processorSupport)) {
GenericType templateReturnType = null != ImportStub.withImportStubByPass(templateGenFunctionType._rawTypeCoreInstance(), processorSupport) ? ((FunctionType) ImportStub.withImportStubByPass(templateGenFunctionType._rawTypeCoreInstance(), processorSupport))._returnType() : null;
// Generics in lambdas are relative to their environment (i.e. the function in which they are defined)
TypeInferenceContext lambdaInferenceContext = state.getTypeInferenceContext().getTopContext();
if (null != templateReturnType) {
FunctionType lambdaFunctionType = Objects.requireNonNull(getRawTypeFromGenericType((LambdaFunction<?>) val, processorSupport));
GenericType concreteGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(lambdaFunctionType._returnType(), lambdaInferenceContext.getTypeParameterToGenericType(), lambdaInferenceContext.getMultiplicityParameterToMultiplicity(), processorSupport);
lambdaFunctionType._returnTypeRemove();
lambdaFunctionType._returnType(concreteGenericType);
if (!org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(templateReturnType, processorSupport)) {
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.register(templateReturnType, concreteGenericType, typeInferenceContext.getParent(), observer);
}
}
Multiplicity templateReturnMultiplicity = null != ImportStub.withImportStubByPass(templateGenFunctionType._rawTypeCoreInstance(), processorSupport) ? ((FunctionType) ImportStub.withImportStubByPass(templateGenFunctionType._rawTypeCoreInstance(), processorSupport))._returnMultiplicity() : null;
if (null != templateReturnMultiplicity) {
FunctionType lambdaFunctionType = Objects.requireNonNull(getRawTypeFromGenericType((LambdaFunction<?>) val, processorSupport));
Multiplicity concreteMultiplicity = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.makeMultiplicityAsConcreteAsPossible(Instance.getValueForMetaPropertyToOneResolved(lambdaFunctionType, M3Properties.returnMultiplicity, processorSupport), lambdaInferenceContext.getMultiplicityParameterToMultiplicity());
lambdaFunctionType._returnMultiplicityRemove();
lambdaFunctionType._returnMultiplicity(concreteMultiplicity);
if (null != concreteMultiplicity) {
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.registerMul(templateReturnMultiplicity, concreteMultiplicity, typeInferenceContext.getParent(), observer);
}
}
}
}
}
}
observer.unShiftTab();
} else {
state.pushTypeInferenceContextAhead();
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.setScope(instance instanceof SimpleFunctionExpression ? ((SimpleFunctionExpression) instance)._funcCoreInstance() : null);
typeInferenceContext.register(instance._genericType(), resolvedGenericType, typeInferenceContext.getParent(), observer);
typeInferenceContext.registerMul(instance._multiplicity(), resolvedMultiplicity, typeInferenceContext.getParent(), observer);
cleanProcess(instance, state, repository, context, processorSupport);
PostProcessor.processElement(matcher, instance, state, processorSupport);
state.popTypeInferenceContextAhead();
}
}
observer.unShiftTab();
observer.unShiftTab();
} else {
observer.parameterInferenceSucceeded();
observer.shiftTab();
observer.shiftTab();
parametersValues.forEachWithIndex((instance, z) -> {
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.register(paramsType.get(z)._genericType(), instance._genericType(), typeInferenceContext.getTopContext(), observer);
typeInferenceContext.registerMul(paramsType.get(z)._multiplicity(), instance._multiplicity(), typeInferenceContext.getTopContext(), observer);
});
// WARNING / returnType may need reverse matching to be found
GenericType returnGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(foundFunctionType._returnType(), state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
observer.returnType(returnGenericType);
if (!org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(returnGenericType, processorSupport) && !state.getTypeInferenceContext().isTop(org.finos.legend.pure.m3.navigation.generictype.GenericType.getTypeParameterName(returnGenericType, processorSupport))) {
observer.shiftTab();
observer.returnTypeNotConcrete();
// reverse matching
parametersValues.forEachWithIndex((instance, z) -> {
GenericType templateGenType = paramsType.get(z)._genericType();
Multiplicity templateMultiplicity = paramsType.get(z)._multiplicity();
GenericType resolvedGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(templateGenType, state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
Multiplicity resolvedMultiplicity = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.makeMultiplicityAsConcreteAsPossible(templateMultiplicity, state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity());
state.pushTypeInferenceContextAhead();
state.getTypeInferenceContext().setScope(instance instanceof FunctionExpression ? ((FunctionExpression) instance)._funcCoreInstance() : null);
observer.processingParameter(functionExpression, z, instance);
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
typeInferenceContext.register(instance._genericType(), resolvedGenericType, typeInferenceContext.getParent(), observer);
typeInferenceContext.registerMul(instance._multiplicity(), resolvedMultiplicity, typeInferenceContext.getParent(), observer);
observer.shiftTab();
observer.reprocessingTheParameter();
observer.shiftTab();
cleanProcess(instance, state, repository, context, processorSupport);
PostProcessor.processElement(matcher, instance, state, processorSupport);
observer.unShiftTab();
observer.finishedProcessParameter();
observer.unShiftTab();
state.popTypeInferenceContextAhead();
});
observer.unShiftTab();
returnGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(foundFunctionType._returnType(), state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
observer.newReturnType(returnGenericType);
}
observer.unShiftTab();
observer.unShiftTab();
observer.finishedRegisteringParametersAndMultiplicities();
}
// We can infer the parameter types for Lambdas given as parameters (now that we know which function to use).
if (success) {
TypeInference.storeInferredTypeParametersInFunctionExpression(functionExpression, state, processorSupport, foundFunction);
// Get the return type information
// Pair<CoreInstance, CoreInstance> result = FunctionExpression.resolveFunctionGenericReturnTypeAndMultiplicity(functionExpression, context, processorSupport);
// result.getOne();
GenericType returnGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(foundFunctionType._returnType(), state.getTypeInferenceContext().getTypeParameterToGenericType(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity(), processorSupport);
Multiplicity returnMultiplicity = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.makeMultiplicityAsConcreteAsPossible(foundFunctionType._returnMultiplicity(), state.getTypeInferenceContext().getMultiplicityParameterToMultiplicity());
if (!org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(returnGenericType, processorSupport) && !state.getTypeInferenceContext().isTop(org.finos.legend.pure.m3.navigation.generictype.GenericType.getTypeParameterName(returnGenericType, processorSupport))) {
throw new PureCompilationException(functionExpression.getSourceInformation(), "The system is not capable of inferring the return type of the function '" + functionExpression.getValueForMetaPropertyToOne(M3Properties.func).getValueForMetaPropertyToOne(M3Properties.functionName).getName() + "'. Check your signatures!");
}
// Update the type
GenericType genericTypeCopy = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.copyGenericTypeAsInferredGenericType(returnGenericType, functionExpression.getSourceInformation(), processorSupport);
functionExpression._genericType(genericTypeCopy);
// Update the multiplicity
Multiplicity returnMultiplicityCopy = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.copyMultiplicity(returnMultiplicity, functionExpression.getSourceInformation(), processorSupport);
functionExpression._multiplicity(returnMultiplicityCopy);
} else {
// Inference failed...
FunctionType functionType = (FunctionType) processorSupport.function_getFunctionType(foundFunction);
GenericType returnGenericType = functionType._returnType();
GenericType genericTypeCopy = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.copyGenericTypeAsInferredGenericType(returnGenericType, functionExpression.getSourceInformation(), processorSupport);
functionExpression._genericType(genericTypeCopy);
Multiplicity returnMultiplicity = functionType._returnMultiplicity();
Multiplicity returnMultiplicityCopy = (Multiplicity) org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity.copyMultiplicity(returnMultiplicity, functionExpression.getSourceInformation(), processorSupport);
functionExpression._multiplicity(returnMultiplicityCopy);
}
if (null == functionName) {
finalFunction = foundFunction;
} else if (!success) {
someInferenceFailed = true;
} else {
Function<?> bestMatch = FunctionExpressionMatcher.getBestFunctionMatch(foundFunctions, parametersValues, functionName, functionExpression.getSourceInformation(), false, processorSupport);
if (bestMatch == foundFunction) {
finalFunction = foundFunction;
}
}
if (null != finalFunction) {
break;
}
// Clean up before re-trying
if (1 < foundFunctions.size()) {
for (ValueSpecification parameterValue : parametersValues) {
cleanProcess(parameterValue, state, repository, context, processorSupport);
}
inferenceSuccess = firstPassTypeInference(functionExpression, parametersValues, state, matcher, repository, context, processorSupport);
}
}
if (null != finalFunction) {
finalFunction._applications(Lists.immutable.<FunctionExpression>withAll(finalFunction._applications()).newWith(functionExpression));
// Update the function in the function expression in the reverse
if ("new_Class_1__String_1__KeyExpression_MANY__T_1_".equals(finalFunction.getName()) || "new_Class_1__String_1__T_1_".equals(finalFunction.getName())) {
this.addTraceForKeyExpressions(functionExpression, processorSupport);
}
if ("copy_T_1__String_1__KeyExpression_MANY__T_1_".equals(finalFunction.getName()) || "copy_T_1__String_1__T_1_".equals(finalFunction.getName())) {
this.addTraceForKeyExpressions(functionExpression, processorSupport);
}
if ("letFunction_String_1__T_m__T_m_".equals(finalFunction.getName())) {
try {
state.getVariableContext().getParent().registerValue(((InstanceValue) parametersValues.get(0))._valuesCoreInstance().toList().get(0).getName(), parametersValues.get(1));
} catch (VariableNameConflictException e) {
throw new PureCompilationException(functionExpression.getSourceInformation(), e.getMessage());
}
}
} else if (!someInferenceFailed) {
throwNoMatchException(functionExpression, state, processorSupport);
}
observer.unShiftTab();
observer.finishedProcessingFunctionExpression(functionExpression);
state.popTypeInferenceContext();
}
Aggregations