Search in sources :

Example 1 with ListIterable

use of org.eclipse.collections.api.list.ListIterable in project legend-pure by finos.

the class ConcreteFunctionDefinitionNameProcessor method process.

public static void process(Function<?> function, ModelRepository repository, ProcessorSupport processorSupport) throws PureCompilationException {
    Package parent = function._package();
    if (parent != null) {
        // Make sure we have a unique name for overloaded functions.
        String signature = getSignatureAndResolveImports(function, repository, processorSupport);
        parent._childrenRemove(function);
        function.setName(signature);
        parent._childrenAdd(function);
        if (function._name() == null) {
            function._name(signature);
        }
        if (parent._children().count(c -> signature.equals(c.getName())) > 1) {
            ListIterable<SourceInformation> sourceInfos = parent._children().collectIf(c -> signature.equals(c.getName()), CoreInstance::getSourceInformation, Lists.mutable.empty()).sortThis();
            String pkg = PackageableElement.getUserPathForPackageableElement(parent);
            if (M3Paths.Root.equals(pkg)) {
                pkg = "::";
            }
            StringBuilder message = new StringBuilder("The function '").append(signature).append("' is defined more than once in the package '").append(pkg).append("' at: ");
            boolean first = true;
            for (SourceInformation sourceInfo : sourceInfos) {
                if (first) {
                    first = false;
                } else {
                    message.append(", ");
                }
                message.append(sourceInfo.getSourceId()).append(" (line:").append(sourceInfo.getLine()).append(" column:").append(sourceInfo.getColumn()).append(')');
            }
            throw new PureCompilationException(function.getSourceInformation(), message.toString());
        }
    }
}
Also used : Multiplicity(org.finos.legend.pure.m3.navigation.multiplicity.Multiplicity) VariableExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.VariableExpression) PackageableElement(org.finos.legend.pure.m3.navigation.PackageableElement.PackageableElement) ModelRepository(org.finos.legend.pure.m4.ModelRepository) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) Lists(org.eclipse.collections.api.factory.Lists) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) MutableList(org.eclipse.collections.api.list.MutableList) Type(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type) M3Paths(org.finos.legend.pure.m3.navigation.M3Paths) ProcessorSupport(org.finos.legend.pure.m3.navigation.ProcessorSupport) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) Function(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.Function) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) ImportStub(org.finos.legend.pure.m3.navigation.importstub.ImportStub) Package(org.finos.legend.pure.m3.coreinstance.Package) ListIterable(org.eclipse.collections.api.list.ListIterable) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException) Package(org.finos.legend.pure.m3.coreinstance.Package) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException)

Example 2 with ListIterable

use of org.eclipse.collections.api.list.ListIterable in project legend-pure by finos.

the class TestDistributedBinaryGraphSerialization method getExpectedObjsFromRuntime.

private ListIterable<Obj> getExpectedObjsFromRuntime(String metadataName) {
    MutableSet<CoreInstance> ignoredClassifiers = PrimitiveUtilities.getPrimitiveTypes(repository).toSet();
    ArrayAdapter.adapt(M3Paths.EnumStub, M3Paths.ImportStub, M3Paths.PropertyStub, M3Paths.RouteNodePropertyStub).collect(processorSupport::package_getByUserPath, ignoredClassifiers);
    IdBuilder idBuilder = IdBuilder.newIdBuilder(DistributedMetadataHelper.getMetadataIdPrefix(metadataName), processorSupport);
    GraphSerializer.ClassifierCaches classifierCaches = new GraphSerializer.ClassifierCaches(processorSupport);
    return GraphNodeIterable.fromModelRepository(repository).reject(i -> ignoredClassifiers.contains(i.getClassifier())).collect(i -> GraphSerializer.buildObj(i, idBuilder, classifierCaches, processorSupport), Lists.mutable.empty());
}
Also used : GraphNodeIterable(org.finos.legend.pure.m4.tools.GraphNodeIterable) ArrayAdapter(org.eclipse.collections.impl.list.fixed.ArrayAdapter) BeforeClass(org.junit.BeforeClass) AbstractPureTestWithCoreCompiled(org.finos.legend.pure.m3.AbstractPureTestWithCoreCompiled) Lists(org.eclipse.collections.api.factory.Lists) IdBuilder(org.finos.legend.pure.runtime.java.compiled.generation.processors.IdBuilder) Test(org.junit.Test) IOException(java.io.IOException) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) MutableList(org.eclipse.collections.api.list.MutableList) Obj(org.finos.legend.pure.runtime.java.compiled.serialization.model.Obj) Function(java.util.function.Function) M3Paths(org.finos.legend.pure.m3.navigation.M3Paths) MutableSet(org.eclipse.collections.api.set.MutableSet) ListMultimap(org.eclipse.collections.api.multimap.list.ListMultimap) GraphSerializer(org.finos.legend.pure.runtime.java.compiled.serialization.GraphSerializer) PrimitiveUtilities(org.finos.legend.pure.m3.navigation.PrimitiveUtilities) ListIterable(org.eclipse.collections.api.list.ListIterable) Assert(org.junit.Assert) GraphSerializer(org.finos.legend.pure.runtime.java.compiled.serialization.GraphSerializer) IdBuilder(org.finos.legend.pure.runtime.java.compiled.generation.processors.IdBuilder) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance)

Example 3 with ListIterable

use of org.eclipse.collections.api.list.ListIterable 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;
}
Also used : ParameterValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ParameterValueSpecificationContext) SimpleFunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.SimpleFunctionExpression) ImportGroup(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup) SetIterable(org.eclipse.collections.api.set.SetIterable) MilestonedPropertyMetaData(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestonedPropertyMetaData) ClassProjection(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassProjection) FunctionDefinitionProcessor(org.finos.legend.pure.m3.compiler.postprocessing.processor.FunctionDefinitionProcessor) MutableList(org.eclipse.collections.api.list.MutableList) ProcessorState(org.finos.legend.pure.m3.compiler.postprocessing.ProcessorState) PureUnmatchedFunctionException(org.finos.legend.pure.m3.exception.PureUnmatchedFunctionException) ProcessorSupport(org.finos.legend.pure.m3.navigation.ProcessorSupport) MutableSet(org.eclipse.collections.api.set.MutableSet) TypeInferenceContext(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceContext) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) RichIterable(org.eclipse.collections.api.RichIterable) GenericTypeTraceability(org.finos.legend.pure.m3.compiler.postprocessing.GenericTypeTraceability) PostProcessor(org.finos.legend.pure.m3.compiler.postprocessing.PostProcessor) Automap(org.finos.legend.pure.m3.compiler.postprocessing.processor.Automap) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException) ModelRepository(org.finos.legend.pure.m4.ModelRepository) KeyValueValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.KeyValueValueSpecificationContext) TypeInference(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInference) ListHelper(org.finos.legend.pure.m3.tools.ListHelper) Matcher(org.finos.legend.pure.m3.tools.matcher.Matcher) Objects(java.util.Objects) UnbindState(org.finos.legend.pure.m3.compiler.unload.unbind.UnbindState) Multiplicity(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.multiplicity.Multiplicity) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) org.finos.legend.pure.m3.navigation._class._Class(org.finos.legend.pure.m3.navigation._class._Class) ValueSpecificationBootstrap(org.finos.legend.pure.m3.navigation.ValueSpecificationBootstrap) ImportStub(org.finos.legend.pure.m3.navigation.importstub.ImportStub) MilestoningDatesPropagationFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningDatesPropagationFunctions) ListIterable(org.eclipse.collections.api.list.ListIterable) Processor(org.finos.legend.pure.m3.compiler.postprocessing.processor.Processor) FunctionExpressionMatcher(org.finos.legend.pure.m3.compiler.postprocessing.functionmatch.FunctionExpressionMatcher) VariableExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.VariableExpression) AbstractProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.AbstractProperty) Instance(org.finos.legend.pure.m3.navigation.Instance) Unbinder(org.finos.legend.pure.m3.compiler.unload.Unbinder) QualifiedProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.QualifiedProperty) Lists(org.eclipse.collections.api.factory.Lists) FunctionDefinition(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.FunctionDefinition) PartitionSet(org.eclipse.collections.api.partition.set.PartitionSet) M3Paths(org.finos.legend.pure.m3.navigation.M3Paths) Context(org.finos.legend.pure.m3.compiler.Context) VariableNameConflictException(org.finos.legend.pure.m3.compiler.postprocessing.VariableContext.VariableNameConflictException) ImportAccessor(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportAccessor) Function(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.Function) FunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.FunctionExpression) TypeInferenceObserver(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceObserver) Package(org.finos.legend.pure.m3.coreinstance.Package) LambdaFunctionInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunctionInstance) Sets(org.eclipse.collections.api.factory.Sets) PackageableElement(org.finos.legend.pure.m3.navigation.PackageableElement.PackageableElement) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) MilestoningFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningFunctions) ClassInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassInstance) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) Type(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type) ValueSpecification(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ValueSpecification) LambdaFunction(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunction) InstanceValue(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.InstanceValue) Visibility(org.finos.legend.pure.m3.compiler.visibility.Visibility) KeyExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.functions.lang.KeyExpression) M3Properties(org.finos.legend.pure.m3.navigation.M3Properties) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) ValueSpecification(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ValueSpecification) TypeInferenceObserver(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceObserver)

Example 4 with ListIterable

use of org.eclipse.collections.api.list.ListIterable 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();
}
Also used : ParameterValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ParameterValueSpecificationContext) SimpleFunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.SimpleFunctionExpression) ImportGroup(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup) SetIterable(org.eclipse.collections.api.set.SetIterable) MilestonedPropertyMetaData(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestonedPropertyMetaData) ClassProjection(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassProjection) FunctionDefinitionProcessor(org.finos.legend.pure.m3.compiler.postprocessing.processor.FunctionDefinitionProcessor) MutableList(org.eclipse.collections.api.list.MutableList) ProcessorState(org.finos.legend.pure.m3.compiler.postprocessing.ProcessorState) PureUnmatchedFunctionException(org.finos.legend.pure.m3.exception.PureUnmatchedFunctionException) ProcessorSupport(org.finos.legend.pure.m3.navigation.ProcessorSupport) MutableSet(org.eclipse.collections.api.set.MutableSet) TypeInferenceContext(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceContext) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) RichIterable(org.eclipse.collections.api.RichIterable) GenericTypeTraceability(org.finos.legend.pure.m3.compiler.postprocessing.GenericTypeTraceability) PostProcessor(org.finos.legend.pure.m3.compiler.postprocessing.PostProcessor) Automap(org.finos.legend.pure.m3.compiler.postprocessing.processor.Automap) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException) ModelRepository(org.finos.legend.pure.m4.ModelRepository) KeyValueValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.KeyValueValueSpecificationContext) TypeInference(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInference) ListHelper(org.finos.legend.pure.m3.tools.ListHelper) Matcher(org.finos.legend.pure.m3.tools.matcher.Matcher) Objects(java.util.Objects) UnbindState(org.finos.legend.pure.m3.compiler.unload.unbind.UnbindState) Multiplicity(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.multiplicity.Multiplicity) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) org.finos.legend.pure.m3.navigation._class._Class(org.finos.legend.pure.m3.navigation._class._Class) ValueSpecificationBootstrap(org.finos.legend.pure.m3.navigation.ValueSpecificationBootstrap) ImportStub(org.finos.legend.pure.m3.navigation.importstub.ImportStub) MilestoningDatesPropagationFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningDatesPropagationFunctions) ListIterable(org.eclipse.collections.api.list.ListIterable) Processor(org.finos.legend.pure.m3.compiler.postprocessing.processor.Processor) FunctionExpressionMatcher(org.finos.legend.pure.m3.compiler.postprocessing.functionmatch.FunctionExpressionMatcher) VariableExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.VariableExpression) AbstractProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.AbstractProperty) Instance(org.finos.legend.pure.m3.navigation.Instance) Unbinder(org.finos.legend.pure.m3.compiler.unload.Unbinder) QualifiedProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.QualifiedProperty) Lists(org.eclipse.collections.api.factory.Lists) FunctionDefinition(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.FunctionDefinition) PartitionSet(org.eclipse.collections.api.partition.set.PartitionSet) M3Paths(org.finos.legend.pure.m3.navigation.M3Paths) Context(org.finos.legend.pure.m3.compiler.Context) VariableNameConflictException(org.finos.legend.pure.m3.compiler.postprocessing.VariableContext.VariableNameConflictException) ImportAccessor(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportAccessor) Function(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.Function) FunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.FunctionExpression) TypeInferenceObserver(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceObserver) Package(org.finos.legend.pure.m3.coreinstance.Package) LambdaFunctionInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunctionInstance) Sets(org.eclipse.collections.api.factory.Sets) PackageableElement(org.finos.legend.pure.m3.navigation.PackageableElement.PackageableElement) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) MilestoningFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningFunctions) ClassInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassInstance) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) Type(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type) ValueSpecification(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ValueSpecification) LambdaFunction(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunction) InstanceValue(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.InstanceValue) Visibility(org.finos.legend.pure.m3.compiler.visibility.Visibility) KeyExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.functions.lang.KeyExpression) M3Properties(org.finos.legend.pure.m3.navigation.M3Properties) ValueSpecification(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ValueSpecification) InstanceValue(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.InstanceValue) VariableNameConflictException(org.finos.legend.pure.m3.compiler.postprocessing.VariableContext.VariableNameConflictException) Function(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.Function) LambdaFunction(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunction) SimpleFunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.SimpleFunctionExpression) FunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.FunctionExpression) SimpleFunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.SimpleFunctionExpression) Multiplicity(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.multiplicity.Multiplicity) TypeInferenceObserver(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceObserver) TypeInferenceContext(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceContext) ClassInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassInstance) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) VariableExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.VariableExpression) LambdaFunction(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunction) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) QualifiedProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.QualifiedProperty)

Example 5 with ListIterable

use of org.eclipse.collections.api.list.ListIterable in project legend-pure by finos.

the class FunctionExpressionProcessor method findFunctionForPropertyBasedOnMultiplicity.

private static AbstractProperty<?> findFunctionForPropertyBasedOnMultiplicity(FunctionExpression propertyFunction, GenericType sourceGenericType, ProcessorState state, ProcessorSupport processorSupport, Matcher matcher) throws PureCompilationException {
    String propertyName = propertyFunction._propertyName()._valuesCoreInstance().toList().get(0).getName();
    Type sourceType = (Type) ImportStub.withImportStubByPass(sourceGenericType._rawTypeCoreInstance(), processorSupport);
    AbstractProperty<?> property = (AbstractProperty<?>) processorSupport.class_findPropertyUsingGeneralization(sourceType, propertyName);
    if (null == property) {
        if (sourceType instanceof ClassProjection) {
            PostProcessor.processElement(matcher, sourceType, state, processorSupport);
            property = (AbstractProperty<?>) processorSupport.class_findPropertyUsingGeneralization(sourceType, propertyName);
        }
        if (null == property) {
            ListIterable<QualifiedProperty<?>> qualifiedProperties = _Class.findQualifiedPropertiesUsingGeneralization(sourceType, propertyName, processorSupport);
            if (qualifiedProperties.isEmpty() && sourceType instanceof ClassProjection) {
                PostProcessor.processElement(matcher, sourceType, state, processorSupport);
                qualifiedProperties = _Class.findQualifiedPropertiesUsingGeneralization(sourceType, propertyName, processorSupport);
            }
            property = (AbstractProperty<?>) findSingleArgumentQualifiedProperty(qualifiedProperties, processorSupport);
            if (null == property) {
                StringBuilder message = new StringBuilder();
                switch(qualifiedProperties.size()) {
                    case 0:
                        {
                            PackageableElement.writeUserPathForPackageableElement(message.append("Can't find the property '").append(propertyName).append("' in the class "), sourceType);
                            break;
                        }
                    case 1:
                        {
                            property = qualifiedProperties.get(0);
                            message.append("The property '").append(propertyName).append("' ");
                            if (MilestoningFunctions.isGeneratedMilestoningProperty(property, processorSupport)) {
                                if (MilestoningFunctions.isAllVersionsInRangeProperty(property, processorSupport)) {
                                    milestoningMissingDateParamErrorMsgForAllVersionInRange(processorSupport, property, message);
                                } else {
                                    milestoningMissingDateParamErrorMsg(processorSupport, property, message);
                                }
                            } else {
                                message.append("requires some parameters.");
                            }
                            break;
                        }
                    default:
                        {
                            if (// bitemporal
                            qualifiedProperties.allSatisfy(qp -> MilestoningFunctions.isGeneratedMilestoningProperty(qp, processorSupport))) {
                                message.append("The property '").append(propertyName).append("' ");
                                milestoningMissingDateParamErrorMsg(processorSupport, qualifiedProperties.getFirst(), message);
                            } else {
                                message.append("There are ").append(qualifiedProperties.size()).append(" properties named '").append(propertyName).append("' and all require additional parameters.");
                            }
                        }
                }
                SourceInformation sourceInfo = propertyFunction._propertyName().getSourceInformation();
                throw new PureCompilationException(sourceInfo, message.toString());
            }
        }
    }
    return property;
}
Also used : ParameterValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ParameterValueSpecificationContext) SimpleFunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.SimpleFunctionExpression) ImportGroup(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup) SetIterable(org.eclipse.collections.api.set.SetIterable) MilestonedPropertyMetaData(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestonedPropertyMetaData) ClassProjection(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassProjection) FunctionDefinitionProcessor(org.finos.legend.pure.m3.compiler.postprocessing.processor.FunctionDefinitionProcessor) MutableList(org.eclipse.collections.api.list.MutableList) ProcessorState(org.finos.legend.pure.m3.compiler.postprocessing.ProcessorState) PureUnmatchedFunctionException(org.finos.legend.pure.m3.exception.PureUnmatchedFunctionException) ProcessorSupport(org.finos.legend.pure.m3.navigation.ProcessorSupport) MutableSet(org.eclipse.collections.api.set.MutableSet) TypeInferenceContext(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceContext) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) RichIterable(org.eclipse.collections.api.RichIterable) GenericTypeTraceability(org.finos.legend.pure.m3.compiler.postprocessing.GenericTypeTraceability) PostProcessor(org.finos.legend.pure.m3.compiler.postprocessing.PostProcessor) Automap(org.finos.legend.pure.m3.compiler.postprocessing.processor.Automap) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException) ModelRepository(org.finos.legend.pure.m4.ModelRepository) KeyValueValueSpecificationContext(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.KeyValueValueSpecificationContext) TypeInference(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInference) ListHelper(org.finos.legend.pure.m3.tools.ListHelper) Matcher(org.finos.legend.pure.m3.tools.matcher.Matcher) Objects(java.util.Objects) UnbindState(org.finos.legend.pure.m3.compiler.unload.unbind.UnbindState) Multiplicity(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.multiplicity.Multiplicity) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) org.finos.legend.pure.m3.navigation._class._Class(org.finos.legend.pure.m3.navigation._class._Class) ValueSpecificationBootstrap(org.finos.legend.pure.m3.navigation.ValueSpecificationBootstrap) ImportStub(org.finos.legend.pure.m3.navigation.importstub.ImportStub) MilestoningDatesPropagationFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningDatesPropagationFunctions) ListIterable(org.eclipse.collections.api.list.ListIterable) Processor(org.finos.legend.pure.m3.compiler.postprocessing.processor.Processor) FunctionExpressionMatcher(org.finos.legend.pure.m3.compiler.postprocessing.functionmatch.FunctionExpressionMatcher) VariableExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.VariableExpression) AbstractProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.AbstractProperty) Instance(org.finos.legend.pure.m3.navigation.Instance) Unbinder(org.finos.legend.pure.m3.compiler.unload.Unbinder) QualifiedProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.QualifiedProperty) Lists(org.eclipse.collections.api.factory.Lists) FunctionDefinition(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.FunctionDefinition) PartitionSet(org.eclipse.collections.api.partition.set.PartitionSet) M3Paths(org.finos.legend.pure.m3.navigation.M3Paths) Context(org.finos.legend.pure.m3.compiler.Context) VariableNameConflictException(org.finos.legend.pure.m3.compiler.postprocessing.VariableContext.VariableNameConflictException) ImportAccessor(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportAccessor) Function(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.Function) FunctionExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.FunctionExpression) TypeInferenceObserver(org.finos.legend.pure.m3.compiler.postprocessing.inference.TypeInferenceObserver) Package(org.finos.legend.pure.m3.coreinstance.Package) LambdaFunctionInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunctionInstance) Sets(org.eclipse.collections.api.factory.Sets) PackageableElement(org.finos.legend.pure.m3.navigation.PackageableElement.PackageableElement) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) MilestoningFunctions(org.finos.legend.pure.m3.compiler.postprocessing.processor.milestoning.MilestoningFunctions) ClassInstance(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassInstance) CoreInstance(org.finos.legend.pure.m4.coreinstance.CoreInstance) Type(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type) ValueSpecification(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.ValueSpecification) LambdaFunction(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.LambdaFunction) InstanceValue(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.valuespecification.InstanceValue) Visibility(org.finos.legend.pure.m3.compiler.visibility.Visibility) KeyExpression(org.finos.legend.pure.m3.coreinstance.meta.pure.functions.lang.KeyExpression) M3Properties(org.finos.legend.pure.m3.navigation.M3Properties) FunctionType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType) GenericType(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType) Type(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type) ClassProjection(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.ClassProjection) AbstractProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.AbstractProperty) SourceInformation(org.finos.legend.pure.m4.coreinstance.SourceInformation) QualifiedProperty(org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.function.property.QualifiedProperty) PureCompilationException(org.finos.legend.pure.m4.exception.PureCompilationException)

Aggregations

ListIterable (org.eclipse.collections.api.list.ListIterable)67 CoreInstance (org.finos.legend.pure.m4.coreinstance.CoreInstance)52 MutableList (org.eclipse.collections.api.list.MutableList)21 RichIterable (org.eclipse.collections.api.RichIterable)20 Lists (org.eclipse.collections.api.factory.Lists)20 MutableSet (org.eclipse.collections.api.set.MutableSet)19 M3Paths (org.finos.legend.pure.m3.navigation.M3Paths)17 ProcessorSupport (org.finos.legend.pure.m3.navigation.ProcessorSupport)17 Test (org.junit.Test)17 Sets (org.eclipse.collections.api.factory.Sets)16 SourceInformation (org.finos.legend.pure.m4.coreinstance.SourceInformation)16 Instance (org.finos.legend.pure.m3.navigation.Instance)14 M3Properties (org.finos.legend.pure.m3.navigation.M3Properties)14 ModelRepository (org.finos.legend.pure.m4.ModelRepository)14 MutableMap (org.eclipse.collections.api.map.MutableMap)13 SetIterable (org.eclipse.collections.api.set.SetIterable)13 FunctionType (org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.FunctionType)13 Function (org.eclipse.collections.api.block.function.Function)12 Type (org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.Type)12 GenericType (org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.GenericType)12