use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.TypeParameter in project legend-pure by finos.
the class TypeInference method storeInferredTypeParametersInFunctionExpression.
public static void storeInferredTypeParametersInFunctionExpression(FunctionExpression functionExpression, ProcessorState state, ProcessorSupport processorSupport, Function<?> foundFunction) throws PureCompilationException {
// Store the inferred params in the FunctionExpression
if (!(foundFunction instanceof QualifiedProperty)) {
TypeInferenceContext typeInferenceContext = state.getTypeInferenceContext();
FunctionType functionType = (FunctionType) processorSupport.function_getFunctionType(foundFunction);
functionType._typeParameters().forEach(typeParameter -> {
CoreInstance value = typeInferenceContext.getTypeParameterValue(typeParameter._name());
if (value != null) {
functionExpression._resolvedTypeParametersAdd((GenericType) value);
} else if (typeInferenceContext.getParent() == null) {
StringBuilder builder = new StringBuilder("The type parameter ").append(typeParameter._name()).append(" was not resolved (").append(foundFunction._functionName()).append(" / ");
org.finos.legend.pure.m3.navigation.function.FunctionType.print(builder, functionType, processorSupport).append(")!");
throw new PureCompilationException(functionExpression.getSourceInformation(), builder.toString());
}
});
functionType._multiplicityParameters().forEach(multiplicityParameter -> {
String parameterName = multiplicityParameter._valuesCoreInstance().getFirst().getName();
CoreInstance value = typeInferenceContext.getMultiplicityParameterValue(parameterName);
if (value != null) {
functionExpression._resolvedMultiplicityParametersAdd((Multiplicity) value);
} else {
throw new PureCompilationException(functionExpression.getSourceInformation(), "The multiplicity parameter " + parameterName + " was not resolved!");
}
});
}
}
use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.TypeParameter in project legend-pure by finos.
the class AntlrContextToM3CoreInstance method classParser.
private CoreInstance classParser(ClassDefinitionContext ctx, ImportGroup importId, boolean addLines) throws PureParserException {
MutableList<Property<? extends CoreInstance, ?>> properties = Lists.mutable.empty();
MutableList<QualifiedProperty<? extends CoreInstance>> qualifiedProperties = Lists.mutable.empty();
MutableList<GenericType> superTypesGenericTypes = Lists.mutable.empty();
boolean isDirectSubTypeofAny = false;
MutableList<String> typeParameterNames = Lists.mutable.empty();
MutableList<Boolean> contravariants = Lists.mutable.empty();
MutableList<String> multiplicityParameterNames = Lists.mutable.empty();
ImportStubInstance ownerType;
ListIterable<CoreInstance> stereotypes = null;
ListIterable<TaggedValue> tags = null;
ClassInstance classInstance;
if (ctx.stereotypes() != null) {
stereotypes = this.stereotypes(ctx.stereotypes(), importId);
}
if (ctx.taggedValues() != null) {
tags = this.taggedValues(ctx.taggedValues(), importId);
}
this.checkExists(ctx.qualifiedName().packagePath(), ctx.qualifiedName().identifier(), null);
if (ctx.typeParametersWithContravarianceAndMultiplicityParameters() != null) {
this.typeParametersWithContravarianceAndMultiplicityParameters(ctx.typeParametersWithContravarianceAndMultiplicityParameters(), typeParameterNames, contravariants, multiplicityParameterNames);
}
if (ctx.projection() != null) {
return this.projectionParser(ctx, importId, addLines, stereotypes, tags);
} else {
if (ctx.EXTENDS() != null) {
for (TypeContext typeCtx : ctx.type()) {
superTypesGenericTypes.add(this.type(typeCtx, typeParameterNames, "", importId, addLines));
}
}
String className = ctx.qualifiedName().identifier().getText();
classInstance = ClassInstance.createPersistent(this.repository, className);
PackageInstance packageInstance = this.buildPackage(ctx.qualifiedName().packagePath());
classInstance._package(packageInstance);
packageInstance._childrenAdd(classInstance);
String fullName = this.getQualifiedNameString(ctx.qualifiedName());
ownerType = ImportStubInstance.createPersistent(this.repository, this.sourceInformation.getPureSourceInformation(ctx.qualifiedName().identifier().getStart()), fullName, importId);
LambdaContext lambdaContext = new LambdaContext(fullName.replace("::", "_"));
MutableList<Constraint> constraints = this.constraints(classInstance, ctx.constraints(), importId, lambdaContext, addLines);
this.propertyParser(ctx.classBody().properties(), properties, qualifiedProperties, typeParameterNames, multiplicityParameterNames, ownerType, importId, 0);
classInstance.setSourceInformation(this.sourceInformation.getPureSourceInformation(ctx.getStart(), ctx.qualifiedName().identifier().getStart(), ctx.getStop()));
if (superTypesGenericTypes.isEmpty()) {
isDirectSubTypeofAny = true;
GenericTypeInstance genericTypeInstance = GenericTypeInstance.createPersistent(this.repository);
genericTypeInstance._rawTypeCoreInstance(this.processorSupport.package_getByUserPath(M3Paths.Any));
superTypesGenericTypes.add(genericTypeInstance);
}
GenericTypeInstance classifierGT = GenericTypeInstance.createPersistent(this.repository);
ClassInstance classType = (ClassInstance) this.processorSupport.package_getByUserPath(M3Paths.Class);
classifierGT._rawTypeCoreInstance(classType);
GenericTypeInstance classifierGTTA = GenericTypeInstance.createPersistent(this.repository);
classifierGTTA._rawTypeCoreInstance(classInstance);
if (!typeParameterNames.isEmpty()) {
MutableList<TypeParameter> typeParameters = Lists.mutable.of();
MutableList<Pair<String, Boolean>> tps = typeParameterNames.zip(contravariants);
for (Pair<String, Boolean> typeParam : tps) {
TypeParameterInstance tp = TypeParameterInstance.createPersistent(this.repository, typeParam.getOne());
tp._contravariant(typeParam.getTwo());
typeParameters.add(tp);
}
classInstance._typeParameters(typeParameters);
MutableList<GenericType> typeArgs = Lists.mutable.of();
for (String typeParamName : typeParameterNames) {
TypeParameterInstance tp = TypeParameterInstance.createPersistent(this.repository, typeParamName);
GenericTypeInstance gt = GenericTypeInstance.createPersistent(this.repository);
gt._typeParameter(tp);
typeArgs.add(gt);
}
classifierGTTA._typeArguments(typeArgs);
}
if (!multiplicityParameterNames.isEmpty()) {
MutableList<Multiplicity> multParameters = Lists.mutable.of();
for (String multiplicityParam : multiplicityParameterNames) {
MultiplicityInstance mult = MultiplicityInstance.createPersistent(this.repository, null, null);
mult._multiplicityParameter(multiplicityParam);
multParameters.add(mult);
}
classInstance._multiplicityParameters(this.processMultiplicityParametersInstance(multiplicityParameterNames));
classifierGTTA._multiplicityArguments(multParameters);
}
classifierGT._typeArguments(Lists.mutable.<GenericType>of(classifierGTTA));
classInstance._classifierGenericType(classifierGT);
if (properties.notEmpty()) {
classInstance._properties(properties);
}
if (qualifiedProperties.notEmpty()) {
classInstance._qualifiedProperties(qualifiedProperties);
}
classInstance._name(ctx.qualifiedName().identifier().getText());
if (stereotypes != null) {
classInstance._stereotypesCoreInstance(stereotypes);
}
if (tags != null) {
classInstance._taggedValues(tags);
}
if (constraints.notEmpty()) {
classInstance._constraints(constraints);
}
MutableList<Generalization> generalizations = Lists.mutable.empty();
for (GenericType superType : superTypesGenericTypes) {
GeneralizationInstance generalizationInstance = GeneralizationInstance.createPersistent(this.repository, superType, classInstance);
generalizations.add(generalizationInstance);
}
classInstance._generalizations(generalizations);
if (isDirectSubTypeofAny) {
MilestoningClassProcessor.addMilestoningProperty(classInstance, this.context, this.processorSupport, this.repository);
}
return classInstance;
}
}
use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.TypeParameter in project legend-pure by finos.
the class GenericTypeMatch method newGenericTypeMatch.
public static GenericTypeMatch newGenericTypeMatch(CoreInstance targetGenericType, CoreInstance valueGenericType, boolean covariant, NullMatchBehavior valueNullMatchBehavior, ParameterMatchBehavior targetParameterMatchBehavior, ParameterMatchBehavior valueParameterMatchBehavior, ProcessorSupport processorSupport) {
// Null checks
if (targetGenericType == null) {
throw new IllegalArgumentException("Target generic type may not be null");
}
if (valueGenericType == null) {
switch(getNullMatchBehavior(valueNullMatchBehavior)) {
case MATCH_ANYTHING:
{
return NULL_MATCH;
}
case MATCH_NOTHING:
{
return null;
}
case ERROR:
{
throw new RuntimeException("Value generic type may not be null");
}
}
}
// Identical generic types
if (GenericType.genericTypesEqual(targetGenericType, valueGenericType, processorSupport)) {
return EXACT_MATCH;
}
CoreInstance targetRawType = Instance.getValueForMetaPropertyToOneResolved(targetGenericType, M3Properties.rawType, processorSupport);
CoreInstance valueRawType = Instance.getValueForMetaPropertyToOneResolved(valueGenericType, M3Properties.rawType, processorSupport);
// Target generic type is not concrete (i.e., targetRawType == null)
if (targetRawType == null) {
switch(getParameterMatchBehavior(targetParameterMatchBehavior)) {
case MATCH_ANYTHING:
{
return NON_CONCRETE_MATCH;
}
case MATCH_CAUTIOUSLY:
{
if (valueRawType == null) {
String targetTypeParameterName = GenericType.getTypeParameterName(targetGenericType);
String valueTypeParameterName = GenericType.getTypeParameterName(valueGenericType);
return (targetTypeParameterName != null) && targetTypeParameterName.equals(valueTypeParameterName) ? NON_CONCRETE_MATCH : null;
}
boolean willMatchParameterBinding = covariant ? Type.isBottomType(valueRawType, processorSupport) : Type.isTopType(valueRawType, processorSupport);
return willMatchParameterBinding ? NON_CONCRETE_MATCH : null;
}
case MATCH_NOTHING:
{
return null;
}
case ERROR:
{
throw new RuntimeException("Target generic type must be concrete, got: " + GenericType.print(targetGenericType, processorSupport));
}
default:
{
throw new RuntimeException("Should not be possible");
}
}
}
// If the value generic type is not concrete (i.e., valueRawType == null), then it only matches Any (for covariant) or Nil (for contravariant)
if (valueRawType == null) {
switch(getParameterMatchBehavior(valueParameterMatchBehavior)) {
case MATCH_ANYTHING:
{
return NON_CONCRETE_MATCH;
}
case MATCH_CAUTIOUSLY:
{
boolean anyParameterBindingWillMatch = covariant ? Type.isTopType(targetRawType, processorSupport) : Type.isBottomType(targetRawType, processorSupport);
return anyParameterBindingWillMatch ? NON_CONCRETE_MATCH : null;
}
case MATCH_NOTHING:
{
return null;
}
case ERROR:
{
throw new RuntimeException("Value generic type must be concrete, got: " + GenericType.print(valueGenericType, processorSupport));
}
}
}
// Both generic types are concrete, so we calculate a match between the raw types
TypeMatch rawTypeMatch = TypeMatch.newTypeMatch(targetRawType, valueRawType, covariant, valueNullMatchBehavior, targetParameterMatchBehavior, valueParameterMatchBehavior, processorSupport);
if (rawTypeMatch == null) {
return null;
}
if (Type.isBottomType(covariant ? valueRawType : targetRawType, processorSupport) || Type.isTopType(covariant ? targetRawType : valueRawType, processorSupport)) {
return new GenericTypeMatch(rawTypeMatch);
}
ListIterable<? extends CoreInstance> targetTypeArguments = targetGenericType.getValueForMetaPropertyToMany(M3Properties.typeArguments);
int typeParameterCount = targetTypeArguments.size();
MutableList<GenericTypeMatch> typeArgumentMatches = FastList.newList(typeParameterCount);
if (typeParameterCount > 0) {
GenericTypeWithXArguments homogenizedTypeArguments = GenericType.resolveClassTypeParameterUsingInheritance(valueGenericType, targetGenericType, processorSupport);
if (homogenizedTypeArguments == null) {
return null;
}
ImmutableMap<String, CoreInstance> valueTypeArgumentsByParam = homogenizedTypeArguments.getArgumentsByParameterName();
if (typeParameterCount != valueTypeArgumentsByParam.size()) {
return null;
}
ListIterable<? extends CoreInstance> typeParameters = targetRawType.getValueForMetaPropertyToMany(M3Properties.typeParameters);
for (int i = 0; i < typeParameterCount; i++) {
CoreInstance typeParameter = typeParameters.get(i);
boolean contravariant = PrimitiveUtilities.getBooleanValue(typeParameter.getValueForMetaPropertyToOne(M3Properties.contravariant), false);
boolean paramCovariant = contravariant ? !covariant : covariant;
CoreInstance valueTypeArgument = valueTypeArgumentsByParam.get(PrimitiveUtilities.getStringValue(typeParameter.getValueForMetaPropertyToOne(M3Properties.name)));
GenericTypeMatch typeArgumentMatch = newGenericTypeMatch(targetTypeArguments.get(i), valueTypeArgument, paramCovariant, valueNullMatchBehavior, targetParameterMatchBehavior, valueParameterMatchBehavior, processorSupport);
if (typeArgumentMatch == null) {
return null;
}
typeArgumentMatches.add(typeArgumentMatch);
}
}
ListIterable<? extends CoreInstance> targetMultArguments = Instance.getValueForMetaPropertyToManyResolved(targetGenericType, M3Properties.multiplicityArguments, processorSupport);
int multParameterCount = targetMultArguments.size();
MutableList<MultiplicityMatch> multArgumentMatches = FastList.newList(multParameterCount);
if (multParameterCount > 0) {
GenericTypeWithXArguments homogenizedMultArguments = GenericType.resolveClassMultiplicityParameterUsingInheritance(valueGenericType, targetRawType, processorSupport);
if (homogenizedMultArguments == null) {
return null;
}
ListIterable<CoreInstance> valueMultArguments = homogenizedMultArguments.extractArgumentsAsMultiplicityParameters(processorSupport);
if (multParameterCount != valueMultArguments.size()) {
return null;
}
for (int i = 0; i < multParameterCount; i++) {
MultiplicityMatch multArgumentMatch = MultiplicityMatch.newMultiplicityMatch(targetMultArguments.get(i), valueMultArguments.get(i), covariant, valueNullMatchBehavior, targetParameterMatchBehavior, valueParameterMatchBehavior);
if (multArgumentMatch == null) {
return null;
}
multArgumentMatches.add(multArgumentMatch);
}
}
return new GenericTypeMatch(rawTypeMatch, typeArgumentMatches, multArgumentMatches);
}
use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.TypeParameter in project legend-pure by finos.
the class Support method processOneLevelGenericType.
private static void processOneLevelGenericType(CoreInstance parameterGenericType, CoreInstance parameterMultiplicity, CoreInstance parameterValueGenericType, CoreInstance parameterValueMultiplicity, MutableMap<String, CoreInstance> inferredTypeParams, MutableMap<String, CoreInstance> inferredMultiplicityParams, ProcessorSupport processorSupport) {
if (!Multiplicity.isMultiplicityConcrete(parameterMultiplicity)) {
String multiplicityParam = Multiplicity.getMultiplicityParameter(parameterMultiplicity);
CoreInstance currentMultiplicity = inferredMultiplicityParams.get(multiplicityParam);
if (currentMultiplicity == null) {
inferredMultiplicityParams.put(multiplicityParam, parameterValueMultiplicity);
} else if (!Multiplicity.isMultiplicityConcrete(currentMultiplicity) && Multiplicity.isMultiplicityConcrete(parameterValueMultiplicity)) {
inferredMultiplicityParams.put(multiplicityParam, parameterValueMultiplicity);
} else if (!Multiplicity.multiplicitiesEqual(currentMultiplicity, parameterValueMultiplicity)) {
inferredMultiplicityParams.put(multiplicityParam, Multiplicity.minSubsumingMultiplicity(currentMultiplicity, parameterValueMultiplicity, processorSupport));
}
}
if (!GenericType.isGenericTypeConcrete(parameterGenericType)) {
String typeParameter = GenericType.getTypeParameterName(parameterGenericType);
CoreInstance currentGenericType = inferredTypeParams.get(typeParameter);
if (currentGenericType == null) {
inferredTypeParams.put(typeParameter, parameterValueGenericType);
} else if (!GenericType.isGenericTypeConcrete(currentGenericType) && GenericType.isGenericTypeConcrete(parameterValueGenericType)) {
inferredTypeParams.put(typeParameter, parameterValueGenericType);
} else if (!GenericType.genericTypesEqual(currentGenericType, parameterValueGenericType, processorSupport)) {
inferredTypeParams.put(typeParameter, GenericType.findBestCommonGenericType(Lists.immutable.with(currentGenericType, parameterValueGenericType), true, false, processorSupport));
}
} else if (FunctionType.isFunctionType(parameterGenericType, processorSupport)) {
inferTypeParameterUsingResolvedFunctionType(parameterGenericType, parameterValueGenericType, inferredTypeParams, inferredMultiplicityParams, processorSupport);
} else if (!Type.isBottomType(parameterValueGenericType.getValueForMetaPropertyToOne(M3Properties.rawType), processorSupport)) {
ListIterable<? extends CoreInstance> typeArguments = Instance.getValueForMetaPropertyToManyResolved(parameterGenericType, M3Properties.typeArguments, processorSupport);
int typeArgumentCount = typeArguments.size();
if (typeArgumentCount > 0) {
CoreInstance parameterRawType = Instance.getValueForMetaPropertyToOneResolved(parameterGenericType, M3Properties.rawType, processorSupport);
ListIterable<? extends CoreInstance> typeParameters = Instance.getValueForMetaPropertyToManyResolved(parameterRawType, M3Properties.typeParameters, processorSupport);
if (typeArgumentCount != typeParameters.size()) {
throw new RuntimeException("Mismatch between the number of type parameters (" + typeParameters.size() + ") and the number of type arguments provided (" + typeArgumentCount + ")");
}
GenericTypeWithXArguments homogenizedTypeArgs = GenericType.resolveClassTypeParameterUsingInheritance(parameterValueGenericType, parameterGenericType, processorSupport);
for (int i = 0; i < typeArgumentCount; i++) {
CoreInstance typeArgument = typeArguments.get(i);
CoreInstance typeParameter = typeParameters.get(i);
String typeParameterNameInSource = PrimitiveUtilities.getStringValue(Instance.getValueForMetaPropertyToOneResolved(typeParameter, M3Properties.name, processorSupport));
processOneLevelGenericType(typeArgument, parameterMultiplicity, homogenizedTypeArgs.getArgumentByParameterName(typeParameterNameInSource), parameterValueMultiplicity, inferredTypeParams, inferredMultiplicityParams, processorSupport);
}
}
}
}
use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel.type.generics.TypeParameter in project legend-pure by finos.
the class FunctionExpressionValidator method validateFunctionExpression.
public static void validateFunctionExpression(Matcher matcher, ValidatorState validatorState, FunctionExpression instance, ModelRepository repository, ProcessorSupport processorSupport) throws PureCompilationException {
Function function = (Function) ImportStub.withImportStubByPass(instance._funcCoreInstance(), processorSupport);
if (function == null) {
throw new RuntimeException("No function found to the expression:\n" + instance.print(""));
}
if ("new_Class_1__String_1__KeyExpression_MANY__T_1_".equals(function.getName()) || "new_Class_1__String_1__T_1_".equals(function.getName())) {
NewValidator.validateNew(matcher, validatorState, instance, processorSupport);
}
if ("copy_T_1__String_1__KeyExpression_MANY__T_1_".equals(function.getName()) || "copy_T_1__String_1__T_1_".equals(function.getName())) {
CopyValidator.validateCopy(matcher, validatorState, instance, processorSupport);
}
if ("extractEnumValue_Enumeration_1__String_1__T_1_".equals(function.getName())) {
EnumValidator.validateEnum(instance, processorSupport);
}
if ("subType_Any_m__T_1__T_m_".equals(function.getName())) {
SubTypeValidator.validateSubType(instance, processorSupport);
}
if (function.getName().startsWith("getAll_Class_1__")) {
GetAllValidator.validate(instance, processorSupport);
}
if (function.getName().startsWith("getAllVersions_Class_1__")) {
GetAllVersionsValidator.validate(instance, processorSupport);
}
if (function.getName().startsWith("getAllVersionsInRange_Class_1__")) {
GetAllVersionsInRangeValidator.validate(instance, processorSupport);
}
MilestoningFunctionExpressionValidator.validateFunctionExpression(instance, function, repository, processorSupport);
FunctionType functionType = (FunctionType) processorSupport.function_getFunctionType(ImportStub.withImportStubByPass(instance._funcCoreInstance(), processorSupport));
ListIterable<? extends VariableExpression> parameters = (ListIterable<? extends VariableExpression>) functionType._parameters();
ListIterable<? extends ValueSpecification> parametersValues = (ListIterable<? extends ValueSpecification>) instance._parametersValues();
int i = 0;
for (ValueSpecification inst : parametersValues) {
Validator.validate(inst, validatorState, matcher, processorSupport);
GenericType genericType = inst._genericType();
Validator.validate(genericType, validatorState, matcher, processorSupport);
if (genericType._rawTypeCoreInstance() != processorSupport.package_getByUserPath(M3Paths.Nil)) {
ListIterable<? extends GenericType> funcP = (ListIterable<? extends GenericType>) parameters.get(i)._genericType()._typeArguments();
GenericType givenInstanceGenericType;
if (!funcP.isEmpty() && org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(parameters.get(i)._genericType(), processorSupport) && org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericTypeConcrete(inst._genericType(), processorSupport)) {
// This line should actually return a Pair (including the resolved multiplicities)
GenericTypeWithXArguments homogenizedTypeArgs = org.finos.legend.pure.m3.navigation.generictype.GenericType.resolveClassTypeParameterUsingInheritance(inst._genericType(), parameters.get(i)._genericType(), processorSupport);
// The empty multiplicities bellow should come from the Pair
givenInstanceGenericType = (GenericType) org.finos.legend.pure.m3.navigation.generictype.GenericType.makeTypeArgumentAsConcreteAsPossible(homogenizedTypeArgs.getGenericType(), homogenizedTypeArgs.getArgumentsByParameterName(), Maps.immutable.<String, CoreInstance>of(), processorSupport);
} else {
givenInstanceGenericType = inst._genericType();
}
ListIterable<? extends GenericType> bound = (ListIterable<? extends GenericType>) givenInstanceGenericType._typeArguments();
if (funcP.size() > bound.size()) {
throw new RuntimeException("Type Arguments mismatch of a function parameter. Function:'" + ImportStub.withImportStubByPass(instance._funcCoreInstance(), processorSupport).getName() + "'" + " / Param:'" + parameters.get(i)._name() + ":" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(parameters.get(i)._genericType(), processorSupport) + "' / Given Instance Type:'" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(inst._genericType(), processorSupport) + "'");
}
for (int k = 0; k < funcP.size(); k++) {
if (ImportStub.withImportStubByPass(funcP.get(k)._rawTypeCoreInstance(), processorSupport) != null) {
Type typeArgument1 = (Type) ImportStub.withImportStubByPass(funcP.get(k)._rawTypeCoreInstance(), processorSupport);
if ("FunctionType".equals(typeArgument1.getClassifier().getName())) {
if (!org.finos.legend.pure.m3.navigation.generictype.GenericType.isGenericCompatibleWith(inst._genericType(), parameters.get(i)._genericType(), processorSupport)) {
throw new PureCompilationException(instance.getSourceInformation(), "typeArgument mismatch! Expected:" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(parameters.get(i)._genericType(), processorSupport) + " Found:" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(inst._genericType(), processorSupport));
}
} else {
Type type = (Type) ImportStub.withImportStubByPass(givenInstanceGenericType._rawTypeCoreInstance(), processorSupport);
ListIterable<? extends TypeParameter> typeParameters = type instanceof Class ? (ListIterable<? extends TypeParameter>) ((Class) type)._typeParameters() : Lists.fixedSize.<TypeParameter>empty();
boolean covariant = org.finos.legend.pure.m3.navigation.typeparameter.TypeParameter.isCovariant(typeParameters.get(k));
Type typeArgument2 = (Type) ImportStub.withImportStubByPass(bound.get(k)._rawTypeCoreInstance(), processorSupport);
if (typeArgument2 != null && (covariant ? !org.finos.legend.pure.m3.navigation.type.Type.subTypeOf(typeArgument2, typeArgument1, processorSupport) : !org.finos.legend.pure.m3.navigation.type.Type.subTypeOf(typeArgument1, typeArgument2, processorSupport))) {
if (!("Any".equals(typeArgument1.getName()) && "FunctionType".equals(typeArgument2.getClassifier().getName()))) {
throw new PureCompilationException(instance.getSourceInformation(), function.getName() + " " + " / typeArgument mismatch! Expected:" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(parameters.get(i)._genericType(), processorSupport) + " Found:" + org.finos.legend.pure.m3.navigation.generictype.GenericType.print(inst._genericType(), processorSupport));
}
}
}
}
}
}
i++;
}
}
Aggregations