mirror of
https://github.com/beefytech/Beef.git
synced 2025-06-08 03:28:20 +02:00
Refactored generic type instances to be a BfGenericTypeInfo member
This commit is contained in:
Brian Fiete
parent
5d9a5f183d
commit
9f00539d90
16 changed files with 504 additions and 578 deletions
|
|
@ -1540,10 +1540,10 @@ bool BfAutoComplete::CheckMemberReference(BfAstNode* target, BfAstNode* dotToken
|
|||
// ?. should look inside nullable types
|
||||
if (targetValue.mType->IsNullable())
|
||||
{
|
||||
BfGenericTypeInstance* nullableType = (BfGenericTypeInstance*)targetValue.mType->ToTypeInstance();
|
||||
BfTypeInstance* nullableType = (BfTypeInstance*)targetValue.mType->ToTypeInstance();
|
||||
targetValue = mModule->MakeAddressable(targetValue);
|
||||
BfIRValue valuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(targetValue.mValue, 0, 1); // mValue
|
||||
targetValue = BfTypedValue(valuePtr, nullableType->mTypeGenericArguments[0], true);
|
||||
targetValue = BfTypedValue(valuePtr, nullableType->mGenericTypeInfo->mTypeGenericArguments[0], true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -466,7 +466,7 @@ bool BfCompiler::IsTypeAccessible(BfType* checkType, BfProject* curProject)
|
|||
auto genericTypeInst = typeInst->ToGenericTypeInstance();
|
||||
if (genericTypeInst != NULL)
|
||||
{
|
||||
for (auto genericArg : genericTypeInst->mTypeGenericArguments)
|
||||
for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
|
||||
if (!IsTypeAccessible(genericArg, curProject))
|
||||
return false;
|
||||
}
|
||||
|
|
@ -515,7 +515,7 @@ bool BfCompiler::IsTypeUsed(BfType* checkType, BfProject* curProject)
|
|||
auto genericTypeInst = typeInst->ToGenericTypeInstance();
|
||||
if (genericTypeInst != NULL)
|
||||
{
|
||||
for (auto genericArg : genericTypeInst->mTypeGenericArguments)
|
||||
for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
|
||||
if (!IsTypeUsed(genericArg, curProject))
|
||||
return false;
|
||||
}
|
||||
|
|
@ -3858,9 +3858,9 @@ void BfCompiler::ProcessAutocompleteTempType()
|
|||
if ((tempTypeDef->IsExtension()) && (actualTypeDef->mIsCombinedPartial) && (typeInst->IsGenericTypeInstance()))
|
||||
{
|
||||
// Add to our extension info map and then take it out at the end...
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)typeInst;
|
||||
auto genericTypeInst = (BfTypeInstance*)typeInst;
|
||||
module->BuildGenericExtensionInfo(genericTypeInst, tempTypeDef);
|
||||
genericTypeInst->mGenericExtensionInfo->mExtensionMap.TryGetValue(tempTypeDef, &genericExEntry);
|
||||
genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(tempTypeDef, &genericExEntry);
|
||||
BF_ASSERT(genericExEntry != NULL);
|
||||
hadTempExtensionInfo = true;
|
||||
}
|
||||
|
|
@ -4195,8 +4195,8 @@ void BfCompiler::ProcessAutocompleteTempType()
|
|||
|
||||
if (hadTempExtensionInfo)
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)typeInst;
|
||||
genericTypeInst->mGenericExtensionInfo->mExtensionMap.Remove(tempTypeDef);
|
||||
auto genericTypeInst = (BfTypeInstance*)typeInst;
|
||||
genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.Remove(tempTypeDef);
|
||||
}
|
||||
|
||||
for (auto checkNode : mResolvePassData->mExteriorAutocompleteCheckNodes)
|
||||
|
|
@ -4478,9 +4478,9 @@ void BfCompiler::GetSymbolReferences()
|
|||
{
|
||||
if (rebuildTypeInst->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInstance = (BfGenericTypeInstance*)rebuildTypeInst;
|
||||
auto genericTypeInstance = (BfTypeInstance*)rebuildTypeInst;
|
||||
|
||||
for (int genericParamIdx = 0; genericParamIdx < (int)genericTypeInstance->mTypeGenericArguments.size(); genericParamIdx++)
|
||||
for (int genericParamIdx = 0; genericParamIdx < (int)genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments.size(); genericParamIdx++)
|
||||
{
|
||||
BfGenericTypeParamInstance genericParamInstance(genericTypeInstance->mTypeDef, genericParamIdx);
|
||||
auto genericParamDef = typeDef->mGenericParamDefs[genericParamIdx];
|
||||
|
|
@ -4967,7 +4967,7 @@ void BfCompiler::PopulateReified()
|
|||
auto typeInst = type->ToTypeInstance();
|
||||
|
||||
if ((typeInst != NULL) && (typeInst->IsGenericTypeInstance()) && (!typeInst->IsUnspecializedType()) &&
|
||||
(!typeInst->IsDelegateFromTypeRef()) && (!typeInst->IsFunctionFromTypeRef()))
|
||||
(!typeInst->IsDelegateFromTypeRef()) && (!typeInst->IsFunctionFromTypeRef()) && (!typeInst->IsTuple()))
|
||||
{
|
||||
auto unspecializedType = module->GetUnspecializedTypeInstance(typeInst);
|
||||
if (!unspecializedType->mIsReified)
|
||||
|
|
@ -7302,16 +7302,16 @@ void BfCompiler::GenerateAutocompleteInfo()
|
|||
}
|
||||
else
|
||||
{
|
||||
BfGenericTypeInstance* genericType = methodEntry.mTypeInstance->ToGenericTypeInstance();
|
||||
BfTypeInstance* genericType = methodEntry.mTypeInstance->ToGenericTypeInstance();
|
||||
if (genericType == NULL)
|
||||
{
|
||||
if (methodEntry.mCurMethodInstance != NULL)
|
||||
genericType = methodEntry.mCurMethodInstance->GetOwner()->ToGenericTypeInstance();
|
||||
}
|
||||
|
||||
if ((genericType != NULL) && (genericParamType->mGenericParamIdx < (int)genericType->mGenericParams.size()))
|
||||
if ((genericType != NULL) && (genericParamType->mGenericParamIdx < (int)genericType->mGenericTypeInfo->mGenericParams.size()))
|
||||
{
|
||||
auto genericParamInstance = genericType->mGenericParams[genericParamType->mGenericParamIdx];
|
||||
auto genericParamInstance = genericType->mGenericTypeInfo->mGenericParams[genericParamType->mGenericParamIdx];
|
||||
methodText += genericParamInstance->GetGenericParamDef()->mName;
|
||||
}
|
||||
else
|
||||
|
|
@ -8331,7 +8331,7 @@ BF_EXPORT const char* BF_CALLTYPE BfCompiler_GetTypeInfo(BfCompiler* bfCompiler,
|
|||
outString += " TypeFailed";
|
||||
if (auto genericTypeInst = typeInst->ToGenericTypeInstance())
|
||||
{
|
||||
if (genericTypeInst->mHadValidateErrors)
|
||||
if (genericTypeInst->mGenericTypeInfo->mHadValidateErrors)
|
||||
outString += " ValidateErrors";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -258,7 +258,7 @@ bool BfConstResolver::PrepareMethodArguments(BfAstNode* targetSrc, BfMethodMatch
|
|||
BfArrayType* arrayType = (BfArrayType*)wantType;
|
||||
if (arrayType->IsIncomplete())
|
||||
mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods);
|
||||
expandedParamsElementType = arrayType->mTypeGenericArguments[0];
|
||||
expandedParamsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -265,6 +265,9 @@ void BfContext::QueueFinishModule(BfModule* module)
|
|||
{
|
||||
bool needsDefer = false;
|
||||
|
||||
BF_ASSERT(module != mScratchModule);
|
||||
BF_ASSERT(module != mUnreifiedModule);
|
||||
|
||||
if (mCompiler->mMaxInterfaceSlots == -1)
|
||||
{
|
||||
if (module->mUsedSlotCount == 0)
|
||||
|
|
@ -791,7 +794,7 @@ void BfContext::ValidateDependencies()
|
|||
// if ((type->IsGenericTypeInstance()) && (type->mDefineState > BfTypeDefineState_Undefined))
|
||||
// {
|
||||
// // We can't contain deleted generic arguments without being deleted ourselves
|
||||
// BfGenericTypeInstance* genericType = (BfGenericTypeInstance*)type;
|
||||
// BfTypeInstance* genericType = (BfTypeInstance*)type;
|
||||
//
|
||||
// for (auto genericTypeArg : genericType->mTypeGenericArguments)
|
||||
// {
|
||||
|
|
@ -1015,16 +1018,16 @@ void BfContext::RebuildType(BfType* type, bool deleteOnDemandTypes, bool rebuild
|
|||
|
||||
if (typeInst->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInstance = (BfGenericTypeInstance*)typeInst;
|
||||
genericTypeInstance->mTypeGenericArgumentRefs.Clear();
|
||||
for (auto genericParam : genericTypeInstance->mGenericParams)
|
||||
auto genericTypeInstance = (BfTypeInstance*)typeInst;
|
||||
genericTypeInstance->mGenericTypeInfo->mTypeGenericArgumentRefs.Clear();
|
||||
for (auto genericParam : genericTypeInstance->mGenericTypeInfo->mGenericParams)
|
||||
genericParam->Release();
|
||||
genericTypeInstance->mGenericParams.Clear();
|
||||
genericTypeInstance->mValidatedGenericConstraints = false;
|
||||
genericTypeInstance->mHadValidateErrors = false;
|
||||
delete genericTypeInstance->mGenericExtensionInfo;
|
||||
genericTypeInstance->mGenericExtensionInfo = NULL;
|
||||
genericTypeInstance->mProjectsReferenced.Clear();
|
||||
genericTypeInstance->mGenericTypeInfo->mGenericParams.Clear();
|
||||
genericTypeInstance->mGenericTypeInfo->mValidatedGenericConstraints = false;
|
||||
genericTypeInstance->mGenericTypeInfo->mHadValidateErrors = false;
|
||||
delete genericTypeInstance->mGenericTypeInfo->mGenericExtensionInfo;
|
||||
genericTypeInstance->mGenericTypeInfo->mGenericExtensionInfo = NULL;
|
||||
genericTypeInstance->mGenericTypeInfo->mProjectsReferenced.Clear();
|
||||
}
|
||||
|
||||
typeInst->mStaticSearchMap.Clear();
|
||||
|
|
@ -1609,9 +1612,9 @@ void BfContext::UpdateAfterDeletingTypes()
|
|||
if (type->IsGenericTypeInstance())
|
||||
{
|
||||
// We can't contain deleted generic arguments without being deleted ourselves
|
||||
BfGenericTypeInstance* genericType = (BfGenericTypeInstance*)type;
|
||||
BfTypeInstance* genericType = (BfTypeInstance*)type;
|
||||
|
||||
for (auto genericTypeArg : genericType->mTypeGenericArguments)
|
||||
for (auto genericTypeArg : genericType->mGenericTypeInfo->mTypeGenericArguments)
|
||||
{
|
||||
BF_ASSERT((!genericTypeArg->IsDeleting()));
|
||||
}
|
||||
|
|
@ -2177,9 +2180,9 @@ void BfContext::GenerateModuleName_TypeInst(BfTypeInstance* typeInst, String& na
|
|||
|
||||
for (int genericIdx = startGenericIdx; genericIdx < (int)typeInst->mTypeDef->mGenericParamDefs.size(); genericIdx++)
|
||||
{
|
||||
auto genericType = (BfGenericTypeInstance*)typeInst;
|
||||
auto genericType = (BfTypeInstance*)typeInst;
|
||||
|
||||
auto type = genericType->mTypeGenericArguments[genericIdx];
|
||||
auto type = genericType->mGenericTypeInfo->mTypeGenericArguments[genericIdx];
|
||||
GenerateModuleName_Type(type, name);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -371,11 +371,10 @@ public:
|
|||
BfAllocPool<BfUnknownSizedArrayType> mUnknownSizedArrayTypePool;
|
||||
BfAllocPool<BfBoxedType> mBoxedTypePool;
|
||||
BfAllocPool<BfTupleType> mTupleTypePool;
|
||||
BfAllocPool<BfGenericTupleType> mGenericTupleTypePool;
|
||||
BfAllocPool<BfTypeAliasType> mAliasTypePool;
|
||||
BfAllocPool<BfRefType> mRefTypePool;
|
||||
BfAllocPool<BfModifiedTypeType> mRetTypeTypePool;
|
||||
BfAllocPool<BfGenericTypeInstance> mGenericTypeInstancePool;
|
||||
BfAllocPool<BfGenericTypeAliasType> mGenericTypeAliasPool;
|
||||
BfAllocPool<BfTypeInstance> mGenericTypeInstancePool;
|
||||
BfAllocPool<BfArrayType> mArrayTypeInstancePool;
|
||||
BfAllocPool<BfGenericParamType> mGenericParamTypePool;
|
||||
BfAllocPool<BfDirectTypeDefReference> mTypeDefTypeRefPool;
|
||||
|
|
@ -384,7 +383,6 @@ public:
|
|||
BfAllocPool<BfConcreteInterfaceType> mConcreteInterfaceTypePool;
|
||||
BfAllocPool<BfConstExprValueType> mConstExprValueTypePool;
|
||||
BfAllocPool<BfDelegateType> mDelegateTypePool;
|
||||
BfAllocPool<BfGenericDelegateType> mGenericDelegateTypePool;
|
||||
BfPrimitiveType* mPrimitiveTypes[BfTypeCode_Length];
|
||||
BfPrimitiveType* mPrimitiveStructTypes[BfTypeCode_Length];
|
||||
|
||||
|
|
|
|||
|
|
@ -255,18 +255,18 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
{
|
||||
if (methodGenericTypeConstraint->IsGenericTypeInstance())
|
||||
{
|
||||
auto wantGenericType = (BfGenericTypeInstance*)methodGenericTypeConstraint;
|
||||
auto wantGenericType = (BfTypeInstance*)methodGenericTypeConstraint;
|
||||
|
||||
auto checkArgType = argType;
|
||||
while (checkArgType != NULL)
|
||||
{
|
||||
if (checkArgType->IsGenericTypeInstance())
|
||||
{
|
||||
auto argGenericType = (BfGenericTypeInstance*)checkArgType;
|
||||
auto argGenericType = (BfTypeInstance*)checkArgType;
|
||||
if (argGenericType->mTypeDef == wantGenericType->mTypeDef)
|
||||
{
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
InferGenericArgument(methodInstance, argGenericType->mTypeGenericArguments[genericArgIdx], wantGenericType->mTypeGenericArguments[genericArgIdx], BfIRValue());
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
InferGenericArgument(methodInstance, argGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], wantGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], BfIRValue());
|
||||
}
|
||||
}
|
||||
else if (checkArgType->IsSizedArray())
|
||||
|
|
@ -274,10 +274,10 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
auto sizedArrayType = (BfSizedArrayType*)checkArgType;
|
||||
if (wantGenericType->mTypeDef == mModule->mCompiler->mSizedArrayTypeDef)
|
||||
{
|
||||
InferGenericArgument(methodInstance, sizedArrayType->mElementType, wantGenericType->mTypeGenericArguments[0], BfIRValue());
|
||||
InferGenericArgument(methodInstance, sizedArrayType->mElementType, wantGenericType->mGenericTypeInfo->mTypeGenericArguments[0], BfIRValue());
|
||||
auto intType = mModule->GetPrimitiveType(BfTypeCode_IntPtr);
|
||||
BfTypedValue arraySize = BfTypedValue(mModule->mBfIRBuilder->CreateConst(BfTypeCode_IntPtr, (uint64)sizedArrayType->mElementCount), intType);
|
||||
InferGenericArgument(methodInstance, mModule->CreateConstExprValueType(arraySize), wantGenericType->mTypeGenericArguments[1], BfIRValue());
|
||||
InferGenericArgument(methodInstance, mModule->CreateConstExprValueType(arraySize), wantGenericType->mGenericTypeInfo->mTypeGenericArguments[1], BfIRValue());
|
||||
}
|
||||
}
|
||||
else if (checkArgType->IsPointer())
|
||||
|
|
@ -285,7 +285,7 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
auto pointerType = (BfPointerType*)checkArgType;
|
||||
if (wantGenericType->mTypeDef == mModule->mCompiler->mPointerTTypeDef)
|
||||
{
|
||||
InferGenericArgument(methodInstance, pointerType->mElementType, wantGenericType->mTypeGenericArguments[0], BfIRValue());
|
||||
InferGenericArgument(methodInstance, pointerType->mElementType, wantGenericType->mGenericTypeInfo->mTypeGenericArguments[0], BfIRValue());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -389,7 +389,7 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
|
||||
if ((wantType->IsGenericTypeInstance()) && (wantType->IsUnspecializedTypeVariation()))
|
||||
{
|
||||
auto wantGenericType = (BfGenericTypeInstance*)wantType;
|
||||
auto wantGenericType = (BfTypeInstance*)wantType;
|
||||
if (argType->IsGenericParam())
|
||||
{
|
||||
auto genericParam = mModule->GetGenericParamInstance((BfGenericParamType*)argType);
|
||||
|
|
@ -405,9 +405,9 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
|
||||
if (argType->IsVar())
|
||||
{
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)wantGenericType->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)wantGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
{
|
||||
BfType* wantGenericArgument = wantGenericType->mTypeGenericArguments[genericArgIdx];
|
||||
BfType* wantGenericArgument = wantGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx];
|
||||
if (!wantGenericArgument->IsUnspecializedType())
|
||||
continue;
|
||||
InferGenericArgument(methodInstance, mModule->GetPrimitiveType(BfTypeCode_Var), wantGenericArgument, BfIRValue());
|
||||
|
|
@ -428,18 +428,18 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
|
|||
|
||||
if (!argType->IsGenericTypeInstance())
|
||||
return true;
|
||||
auto argGenericType = (BfGenericTypeInstance*)argType;
|
||||
auto argGenericType = (BfTypeInstance*)argType;
|
||||
if (argGenericType->mTypeDef != wantGenericType->mTypeDef)
|
||||
return true;
|
||||
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
{
|
||||
BfType* wantGenericArgument = wantGenericType->mTypeGenericArguments[genericArgIdx];
|
||||
BfType* wantGenericArgument = wantGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx];
|
||||
if (!wantGenericArgument->IsUnspecializedType())
|
||||
continue;
|
||||
if (!_AddToCheckedSet(argType, mCheckedTypeSet, alreadyChecked))
|
||||
return true;
|
||||
InferGenericArgument(methodInstance, argGenericType->mTypeGenericArguments[genericArgIdx], wantGenericArgument, BfIRValue());
|
||||
InferGenericArgument(methodInstance, argGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], wantGenericArgument, BfIRValue());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -824,12 +824,12 @@ void BfMethodMatcher::CompareMethods(BfMethodInstance* prevMethodInstance, BfTyp
|
|||
{
|
||||
if ((newType->IsUnspecializedType()) && (newType->IsGenericTypeInstance()))
|
||||
{
|
||||
BfGenericTypeInstance* newGenericType = (BfGenericTypeInstance*)newType;
|
||||
BfGenericTypeInstance* prevGenericType = (BfGenericTypeInstance*)prevType;
|
||||
BfTypeInstance* newGenericType = (BfTypeInstance*)newType;
|
||||
BfTypeInstance* prevGenericType = (BfTypeInstance*)prevType;
|
||||
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)newGenericType->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
for (int genericArgIdx = 0; genericArgIdx < (int)newGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++)
|
||||
{
|
||||
_CompareParamTypes(newGenericType->mTypeGenericArguments[genericArgIdx], prevGenericType->mTypeGenericArguments[genericArgIdx]);
|
||||
_CompareParamTypes(newGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], prevGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -901,13 +901,13 @@ void BfMethodMatcher::CompareMethods(BfMethodInstance* prevMethodInstance, BfTyp
|
|||
auto owner = newMethodInstance->GetOwner();
|
||||
if ((newMethodDef->mDeclaringType != prevMethodDef->mDeclaringType) && (owner->IsGenericTypeInstance()))
|
||||
{
|
||||
auto genericOwner = (BfGenericTypeInstance*)owner;
|
||||
if (genericOwner->mGenericExtensionInfo != NULL)
|
||||
auto genericOwner = (BfTypeInstance*)owner;
|
||||
if (genericOwner->mGenericTypeInfo->mGenericExtensionInfo != NULL)
|
||||
{
|
||||
BfGenericExtensionEntry* newGenericExtesionEntry = NULL;
|
||||
BfGenericExtensionEntry* prevGenericExtesionEntry = NULL;
|
||||
if ((genericOwner->mGenericExtensionInfo->mExtensionMap.TryGetValue(newMethodDef->mDeclaringType, &newGenericExtesionEntry)) &&
|
||||
(genericOwner->mGenericExtensionInfo->mExtensionMap.TryGetValue(prevMethodDef->mDeclaringType, &prevGenericExtesionEntry)))
|
||||
if ((genericOwner->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(newMethodDef->mDeclaringType, &newGenericExtesionEntry)) &&
|
||||
(genericOwner->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(prevMethodDef->mDeclaringType, &prevGenericExtesionEntry)))
|
||||
{
|
||||
if ((newGenericExtesionEntry->mGenericParams.size() == prevGenericExtesionEntry->mGenericParams.size()))
|
||||
{
|
||||
|
|
@ -1520,7 +1520,7 @@ bool BfMethodMatcher::CheckMethod(BfTypeInstance* targetTypeInstance, BfTypeInst
|
|||
if (paramsArrayType->IsArray())
|
||||
{
|
||||
auto arrayType = (BfArrayType*)paramsArrayType;
|
||||
paramsElementType = arrayType->mTypeGenericArguments[0];
|
||||
paramsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
|
||||
while (argIdx < (int)mArguments.size())
|
||||
{
|
||||
|
|
@ -5495,7 +5495,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
|
|||
{
|
||||
BfArrayType* arrayType = (BfArrayType*)wantType;
|
||||
mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods);
|
||||
expandedParamsElementType = arrayType->mTypeGenericArguments[0];
|
||||
expandedParamsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
|
||||
int arrayClassSize = arrayType->mInstSize - expandedParamsElementType->mSize;
|
||||
|
||||
|
|
@ -5527,10 +5527,10 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
|
|||
{
|
||||
int numElements = (int)argValues.size() - argIdx;
|
||||
auto genericTypeInst = wantType->ToGenericTypeInstance();
|
||||
expandedParamsElementType = genericTypeInst->mTypeGenericArguments[0];
|
||||
expandedParamsElementType = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
|
||||
expandedParamsArray = BfTypedValue(mModule->CreateAlloca(wantType), wantType, true);
|
||||
expandedParamAlloca = mModule->CreateAlloca(genericTypeInst->mTypeGenericArguments[0], true, NULL, mModule->GetConstValue(numElements));
|
||||
expandedParamAlloca = mModule->CreateAlloca(genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0], true, NULL, mModule->GetConstValue(numElements));
|
||||
mModule->mBfIRBuilder->CreateStore(expandedParamAlloca, mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 1));
|
||||
mModule->mBfIRBuilder->CreateStore(mModule->GetConstValue(numElements), mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 2));
|
||||
|
||||
|
|
@ -8447,7 +8447,7 @@ bool BfExprEvaluator::LookupTypeProp(BfTypeOfExpression* typeOfExpr, BfIdentifie
|
|||
else if (memberName == "GenericParamCount")
|
||||
{
|
||||
auto genericTypeInst = type->ToGenericTypeInstance();
|
||||
_Int32Result((genericTypeInst != NULL) ? (int)genericTypeInst->mTypeGenericArguments.size() : 0);
|
||||
_Int32Result((genericTypeInst != NULL) ? (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size() : 0);
|
||||
}
|
||||
else if (memberName == "Size")
|
||||
_Int32Result(type->mSize);
|
||||
|
|
@ -11338,7 +11338,7 @@ void BfExprEvaluator::CheckObjectCreateTypeRef(BfType* expectingType, BfAstNode*
|
|||
while (expectingType->IsArray())
|
||||
{
|
||||
auto arrayType = (BfArrayType*)expectingType;
|
||||
expectingType = arrayType->mTypeGenericArguments[0];
|
||||
expectingType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
}
|
||||
|
||||
auto expectingTypeInst = expectingType->ToTypeInstance();
|
||||
|
|
@ -14549,12 +14549,12 @@ BfTypedValue BfExprEvaluator::GetResult(bool clearResult, bool resolveGenericTyp
|
|||
bool handled = false;
|
||||
if (mPropTarget.mType->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)mPropTarget.mType;
|
||||
auto genericTypeInst = (BfTypeInstance*)mPropTarget.mType;
|
||||
if (genericTypeInst->mTypeDef == mModule->mCompiler->mSizedArrayTypeDef)
|
||||
{
|
||||
if (mPropDef->mName == "Count")
|
||||
{
|
||||
auto sizedType = genericTypeInst->mTypeGenericArguments[1];
|
||||
auto sizedType = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[1];
|
||||
if (sizedType->IsConstExprValue())
|
||||
{
|
||||
auto constExprType = (BfConstExprValueType*)sizedType;
|
||||
|
|
@ -16371,7 +16371,7 @@ BfTypedValue BfExprEvaluator::SetupNullConditional(BfTypedValue thisValue, BfTok
|
|||
|
||||
if (thisValue.mType->IsNullable())
|
||||
{
|
||||
BfGenericTypeInstance* nullableType = (BfGenericTypeInstance*)thisValue.mType->ToTypeInstance();
|
||||
BfTypeInstance* nullableType = (BfTypeInstance*)thisValue.mType->ToTypeInstance();
|
||||
auto elementType = nullableType->GetUnderlyingType();
|
||||
if (elementType->IsValuelessType())
|
||||
{
|
||||
|
|
@ -17126,8 +17126,8 @@ BfTypedValue BfExprEvaluator::PerformUnaryOperation_TryOperator(const BfTypedVal
|
|||
// Check type generic constraints
|
||||
if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType()))
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)mModule->mCurTypeInstance;
|
||||
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericParams.size(); genericParamIdx++)
|
||||
auto genericTypeInst = (BfTypeInstance*)mModule->mCurTypeInstance;
|
||||
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericTypeInfo->mGenericParams.size(); genericParamIdx++)
|
||||
{
|
||||
auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx);
|
||||
for (auto& opConstraint : genericParam->mOperatorConstraints)
|
||||
|
|
@ -18498,8 +18498,8 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod
|
|||
// Check type generic constraints
|
||||
if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType()))
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)mModule->mCurTypeInstance;
|
||||
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericParams.size(); genericParamIdx++)
|
||||
auto genericTypeInst = (BfTypeInstance*)mModule->mCurTypeInstance;
|
||||
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericTypeInfo->mGenericParams.size(); genericParamIdx++)
|
||||
{
|
||||
auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx);
|
||||
for (auto& opConstraint : genericParam->mOperatorConstraints)
|
||||
|
|
|
|||
|
|
@ -2245,7 +2245,7 @@ void BfIRBuilder::CreateTypeDeclaration(BfType* type, bool forceDbgDefine)
|
|||
if (checkType->IsArray())
|
||||
{
|
||||
BfArrayType* arrayType = (BfArrayType*)checkType;
|
||||
checkType = arrayType->mTypeGenericArguments[0];
|
||||
checkType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
}
|
||||
BfTypeInstance* outerType = NULL;
|
||||
if (!checkType->IsBoxed())
|
||||
|
|
|
|||
|
|
@ -211,11 +211,11 @@ void BfGNUMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
|
|||
}
|
||||
|
||||
BF_ASSERT(checkType->IsGenericTypeInstance());
|
||||
BfGenericTypeInstance* genericTypeInstance = (BfGenericTypeInstance*)checkType;
|
||||
BfTypeInstance* genericTypeInstance = (BfTypeInstance*)checkType;
|
||||
|
||||
for (int genericParamIdx = genericParamStart; genericParamIdx < (int) typeDef->mGenericParamDefs.size(); genericParamIdx++)
|
||||
{
|
||||
auto genericParam = genericTypeInstance->mTypeGenericArguments[genericParamIdx];
|
||||
auto genericParam = genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[genericParamIdx];
|
||||
|
||||
Mangle(mangleContext, name, genericParam);
|
||||
}
|
||||
|
|
@ -1203,9 +1203,9 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
|
|||
{
|
||||
auto typeDef = newNameSub.mTypeInst->mTypeDef;
|
||||
|
||||
BfGenericTypeInstance* genericTypeInst = NULL;
|
||||
BfTypeInstance* genericTypeInst = NULL;
|
||||
if (newNameSub.mTypeInst->IsGenericTypeInstance())
|
||||
genericTypeInst = (BfGenericTypeInstance*)newNameSub.mTypeInst;
|
||||
genericTypeInst = (BfTypeInstance*)newNameSub.mTypeInst;
|
||||
|
||||
int numOuterGenericParams = 0;
|
||||
if ((!mangleContext.mIsSafeMangle) && (typeDef->mOuterType != NULL))
|
||||
|
|
@ -1249,7 +1249,7 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
|
|||
|
||||
if (genericTypeInst != NULL)
|
||||
{
|
||||
AddGenericArgs(mangleContext, name, genericTypeInst->mTypeGenericArguments, numOuterGenericParams);
|
||||
AddGenericArgs(mangleContext, name, genericTypeInst->mGenericTypeInfo->mTypeGenericArguments, numOuterGenericParams);
|
||||
name += '@';
|
||||
}
|
||||
}
|
||||
|
|
@ -1276,10 +1276,10 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
|
|||
|
||||
void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfTypeInstance* typeInstance, bool isAlreadyStarted, bool isOuterType)
|
||||
{
|
||||
BfGenericTypeInstance* genericTypeInst = NULL;
|
||||
BfTypeInstance* genericTypeInst = NULL;
|
||||
if (typeInstance->IsGenericTypeInstance())
|
||||
{
|
||||
genericTypeInst = (BfGenericTypeInstance*)typeInstance;
|
||||
genericTypeInst = (BfTypeInstance*)typeInstance;
|
||||
}
|
||||
|
||||
auto typeDef = typeInstance->mTypeDef;
|
||||
|
|
|
|||
|
|
@ -2969,8 +2969,8 @@ bool BfModule::CheckDefineMemberProtection(BfProtection protection, BfType* memb
|
|||
if (memberTypeInstance->IsGenericTypeInstance())
|
||||
{
|
||||
// When we're a generic struct, our data layout can depend on our generic parameters as well
|
||||
auto genericTypeInstance = (BfGenericTypeInstance*) memberTypeInstance;
|
||||
for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments)
|
||||
auto genericTypeInstance = (BfTypeInstance*) memberTypeInstance;
|
||||
for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
|
||||
{
|
||||
if (!CheckDefineMemberProtection(protection, typeGenericArg))
|
||||
return false;
|
||||
|
|
@ -3011,7 +3011,7 @@ void BfModule::AddDependency(BfType* usedType, BfType* userType, BfDependencyMap
|
|||
usedType = usedType->GetUnderlyingType();
|
||||
else if (usedType->IsArray())
|
||||
{
|
||||
usedType = ((BfGenericTypeInstance*)usedType)->mTypeGenericArguments[0];
|
||||
usedType = ((BfTypeInstance*)usedType)->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
}
|
||||
else
|
||||
break;
|
||||
|
|
@ -3105,8 +3105,8 @@ void BfModule::AddDependency(BfType* usedType, BfType* userType, BfDependencyMap
|
|||
return;
|
||||
if (checkDType->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInstance = (BfGenericTypeInstance*) checkDType;
|
||||
for (auto genericArg : genericTypeInstance->mTypeGenericArguments)
|
||||
auto genericTypeInstance = (BfTypeInstance*) checkDType;
|
||||
for (auto genericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
|
||||
{
|
||||
AddDependency(genericArg, userType, BfDependencyMap::DependencyFlag_GenericArgRef);
|
||||
}
|
||||
|
|
@ -6147,7 +6147,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
|
|||
SizedArray<BfIRValue, 4> unspecializedData =
|
||||
{
|
||||
typeInstanceData,
|
||||
GetConstValue((int)genericTypeInstance->mTypeGenericArguments.size(), byteType), // mGenericParamCount
|
||||
GetConstValue((int)genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments.size(), byteType), // mGenericParamCount
|
||||
};
|
||||
auto reflectUnspecializedGenericType = ResolveTypeDef(mCompiler->mReflectUnspecializedGenericType);
|
||||
typeInstanceDataType = mBfIRBuilder->MapTypeInst(reflectUnspecializedGenericType->ToTypeInstance(), BfIRPopulateType_Full);
|
||||
|
|
@ -6160,7 +6160,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
|
|||
auto unspecializedType = ResolveTypeDef(typeInstance->mTypeDef);
|
||||
|
||||
SizedArray<BfIRValue, 4> resolvedTypes;
|
||||
for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments)
|
||||
for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
|
||||
resolvedTypes.push_back(GetConstValue(typeGenericArg->mTypeId, typeIdType));
|
||||
|
||||
auto typeIRType = mBfIRBuilder->MapType(typeIdType);
|
||||
|
|
@ -6185,7 +6185,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
|
|||
{
|
||||
auto arrayType = (BfArrayType*)typeInstance;
|
||||
|
||||
BfType* elementType = genericTypeInstance->mTypeGenericArguments[0];
|
||||
BfType* elementType = genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
BfFieldInstance* elementFieldInstance = &genericTypeInstance->mFieldInstances[0];
|
||||
|
||||
SizedArray<BfIRValue, 4> arrayData =
|
||||
|
|
@ -6911,12 +6911,12 @@ bool BfModule::CheckGenericConstraints(const BfGenericParamSource& genericParamS
|
|||
auto sizedArrayType = (BfSizedArrayType*)origCheckArgType;
|
||||
if (convCheckConstraint->IsGenericTypeInstance())
|
||||
{
|
||||
auto convCheckConstraintInst = (BfGenericTypeInstance*)convCheckConstraint;
|
||||
auto convCheckConstraintInst = (BfTypeInstance*)convCheckConstraint;
|
||||
if (convCheckConstraintInst->mTypeDef == mCompiler->mSizedArrayTypeDef)
|
||||
{
|
||||
if (convCheckConstraintInst->mTypeGenericArguments[0] == sizedArrayType->mElementType)
|
||||
if (convCheckConstraintInst->mGenericTypeInfo->mTypeGenericArguments[0] == sizedArrayType->mElementType)
|
||||
{
|
||||
auto constExprValueType = (BfConstExprValueType*)convCheckConstraintInst->mTypeGenericArguments[1];
|
||||
auto constExprValueType = (BfConstExprValueType*)convCheckConstraintInst->mGenericTypeInfo->mTypeGenericArguments[1];
|
||||
if (sizedArrayType->mElementCount == constExprValueType->mValue.mInt64)
|
||||
constraintMatched = true;
|
||||
}
|
||||
|
|
@ -9028,7 +9028,10 @@ BfMethodInstance* BfModule::GetUnspecializedMethodInstance(BfMethodInstance* met
|
|||
if (!owner->IsGenericTypeInstance())
|
||||
return methodInstance;
|
||||
|
||||
auto genericType = (BfGenericTypeInstance*)owner;
|
||||
BF_ASSERT(!owner->IsDelegateFromTypeRef());
|
||||
BF_ASSERT(!owner->IsTuple());
|
||||
|
||||
auto genericType = (BfTypeInstance*)owner;
|
||||
if (genericType->IsUnspecializedType())
|
||||
return methodInstance;
|
||||
|
||||
|
|
@ -11540,10 +11543,10 @@ BfModuleMethodInstance BfModule::GetMethodInstance(BfTypeInstance* typeInst, BfM
|
|||
isExternalExtensionMethod = true;
|
||||
if (typeInst->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)typeInst;
|
||||
if (genericTypeInst->mProjectsReferenced.empty())
|
||||
auto genericTypeInst = (BfTypeInstance*)typeInst;
|
||||
if (genericTypeInst->mGenericTypeInfo->mProjectsReferenced.empty())
|
||||
genericTypeInst->GenerateProjectsReferenced();
|
||||
if (genericTypeInst->mProjectsReferenced.Contains(specProject))
|
||||
if (genericTypeInst->mGenericTypeInfo->mProjectsReferenced.Contains(specProject))
|
||||
{
|
||||
// This is a generic type where a generic param is already confined to the project in question
|
||||
isExternalExtensionMethod = false;
|
||||
|
|
@ -11563,11 +11566,11 @@ BfModuleMethodInstance BfModule::GetMethodInstance(BfTypeInstance* typeInst, BfM
|
|||
int typeProjectsCounts = 0;
|
||||
if (typeInst->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericTypeInst = (BfGenericTypeInstance*)typeInst;
|
||||
if (genericTypeInst->mProjectsReferenced.empty())
|
||||
auto genericTypeInst = (BfTypeInstance*)typeInst;
|
||||
if (genericTypeInst->mGenericTypeInfo->mProjectsReferenced.empty())
|
||||
genericTypeInst->GenerateProjectsReferenced();
|
||||
typeProjectsCounts = (int)genericTypeInst->mProjectsReferenced.size();
|
||||
projectList.Insert(0, &genericTypeInst->mProjectsReferenced[0], genericTypeInst->mProjectsReferenced.size());
|
||||
typeProjectsCounts = (int)genericTypeInst->mGenericTypeInfo->mProjectsReferenced.size();
|
||||
projectList.Insert(0, &genericTypeInst->mGenericTypeInfo->mProjectsReferenced[0], genericTypeInst->mGenericTypeInfo->mProjectsReferenced.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -15235,7 +15238,7 @@ void BfModule::EmitIteratorBlock(bool& skipBody)
|
|||
if ((retTypeInst->mTypeDef == mCompiler->mGenericIEnumerableTypeDef) ||
|
||||
(retTypeInst->mTypeDef == mCompiler->mGenericIEnumeratorTypeDef))
|
||||
{
|
||||
innerRetType = retTypeInst->mTypeGenericArguments[0];
|
||||
innerRetType = retTypeInst->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1575,9 +1575,9 @@ public:
|
|||
virtual void Visit(BfInlineAsmStatement* asmStmt) override;
|
||||
|
||||
// Type helpers
|
||||
BfGenericExtensionEntry* BuildGenericExtensionInfo(BfGenericTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef);
|
||||
BfGenericExtensionEntry* BuildGenericExtensionInfo(BfTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef);
|
||||
bool BuildGenericParams(BfType* resolvedTypeRef);
|
||||
bool ValidateGenericConstraints(BfTypeReference* typeRef, BfGenericTypeInstance* genericTypeInstance, bool ignoreErrors);
|
||||
bool ValidateGenericConstraints(BfTypeReference* typeRef, BfTypeInstance* genericTypeInstance, bool ignoreErrors);
|
||||
bool AreConstraintsSubset(BfGenericParamInstance* checkInner, BfGenericParamInstance* checkOuter);
|
||||
bool CheckConstraintState(BfAstNode* refNode);
|
||||
bool ShouldAllowMultipleDefinitions(BfTypeInstance* typeInst, BfTypeDef* firstDeclaringTypeDef, BfTypeDef* secondDeclaringTypeDef);
|
||||
|
|
@ -1614,7 +1614,7 @@ public:
|
|||
bool IsThreadLocal(BfFieldInstance* fieldInstance);
|
||||
BfType* ResolveVarFieldType(BfTypeInstance* typeInst, BfFieldInstance* fieldInstance, BfFieldDef* field);
|
||||
void FindSubTypes(BfTypeInstance* classType, SizedArrayImpl<int>* outVals, SizedArrayImpl<BfTypeInstance*>* exChecks, bool isInterfacePass);
|
||||
BfType* CheckUnspecializedGenericType(BfGenericTypeInstance* genericTypeInst, BfPopulateType populateType);
|
||||
BfType* CheckUnspecializedGenericType(BfTypeInstance* genericTypeInst, BfPopulateType populateType);
|
||||
BfTypeInstance* GetUnspecializedTypeInstance(BfTypeInstance* typeInst);
|
||||
BfArrayType* CreateArrayType(BfType* resolvedType, int dimensions);
|
||||
BfSizedArrayType* CreateSizedArrayType(BfType* resolvedType, int size);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -579,8 +579,8 @@ bool Beefy::BfMethodInstance::IsSpecializedGenericMethodOrType()
|
|||
auto owner = GetOwner();
|
||||
if (!owner->IsGenericTypeInstance())
|
||||
return false;
|
||||
BfGenericTypeInstance* genericTypeInstance = (BfGenericTypeInstance*)owner;
|
||||
return !genericTypeInstance->mIsUnspecialized;
|
||||
BfTypeInstance* genericTypeInstance = (BfTypeInstance*)owner;
|
||||
return !genericTypeInstance->mGenericTypeInfo->mIsUnspecialized;
|
||||
}
|
||||
|
||||
bool BfMethodInstance::IsSpecializedByAutoCompleteMethod()
|
||||
|
|
@ -1190,6 +1190,7 @@ BfMethodInstanceGroup::~BfMethodInstanceGroup()
|
|||
BfTypeInstance::~BfTypeInstance()
|
||||
{
|
||||
delete mTypeInfoEx;
|
||||
delete mGenericTypeInfo;
|
||||
delete mCustomAttributes;
|
||||
delete mAttributeData;
|
||||
for (auto methodInst : mInternalMethods)
|
||||
|
|
@ -1494,6 +1495,9 @@ bool BfTypeInstance::GetResultInfo(BfType*& valueType, int& okTagId)
|
|||
|
||||
void BfTypeInstance::ReportMemory(MemReporter* memReporter)
|
||||
{
|
||||
if (mGenericTypeInfo != NULL)
|
||||
mGenericTypeInfo->ReportMemory(memReporter);
|
||||
|
||||
memReporter->Add(sizeof(BfTypeInstance));
|
||||
|
||||
int depSize = 0;
|
||||
|
|
@ -1589,7 +1593,7 @@ BfGenericExtensionEntry::~BfGenericExtensionEntry()
|
|||
|
||||
///
|
||||
|
||||
BfGenericTypeInstance::~BfGenericTypeInstance()
|
||||
BfGenericTypeInfo::~BfGenericTypeInfo()
|
||||
{
|
||||
for (auto genericParamInstance : mGenericParams)
|
||||
genericParamInstance->Release();
|
||||
|
|
@ -1597,33 +1601,39 @@ BfGenericTypeInstance::~BfGenericTypeInstance()
|
|||
delete mGenericExtensionInfo;
|
||||
}
|
||||
|
||||
BfGenericTypeInstance::GenericParamsVector* BfGenericTypeInstance::GetGenericParamsVector(BfTypeDef* declaringTypeDef)
|
||||
BfGenericTypeInfo::GenericParamsVector* BfTypeInstance::GetGenericParamsVector(BfTypeDef* declaringTypeDef)
|
||||
{
|
||||
if (mGenericTypeInfo == NULL)
|
||||
return NULL;
|
||||
if ((declaringTypeDef == mTypeDef) ||
|
||||
(declaringTypeDef->mTypeDeclaration == mTypeDef->mTypeDeclaration))
|
||||
return &mGenericParams;
|
||||
return &mGenericTypeInfo->mGenericParams;
|
||||
|
||||
if (mGenericExtensionInfo == NULL)
|
||||
if (mGenericTypeInfo->mGenericExtensionInfo == NULL)
|
||||
return NULL;
|
||||
|
||||
BfGenericExtensionEntry* genericExEntry = NULL;
|
||||
if (mGenericExtensionInfo->mExtensionMap.TryGetValue(declaringTypeDef, &genericExEntry))
|
||||
if (mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(declaringTypeDef, &genericExEntry))
|
||||
return &genericExEntry->mGenericParams;
|
||||
|
||||
return &mGenericParams;
|
||||
return &mGenericTypeInfo->mGenericParams;
|
||||
}
|
||||
|
||||
void BfGenericTypeInstance::GenerateProjectsReferenced()
|
||||
void BfTypeInstance::GenerateProjectsReferenced()
|
||||
{
|
||||
BF_ASSERT(mProjectsReferenced.empty());
|
||||
mProjectsReferenced.push_back(mTypeDef->mProject);
|
||||
for (auto genericArgType : mTypeGenericArguments)
|
||||
BfTypeUtils::GetProjectList(genericArgType, &mProjectsReferenced, 0);
|
||||
if (mGenericTypeInfo == NULL)
|
||||
return;
|
||||
BF_ASSERT(mGenericTypeInfo->mProjectsReferenced.empty());
|
||||
mGenericTypeInfo->mProjectsReferenced.push_back(mTypeDef->mProject);
|
||||
for (auto genericArgType : mGenericTypeInfo->mTypeGenericArguments)
|
||||
BfTypeUtils::GetProjectList(genericArgType, &mGenericTypeInfo->mProjectsReferenced, 0);
|
||||
}
|
||||
|
||||
bool BfGenericTypeInstance::IsSpecializedByAutoCompleteMethod()
|
||||
bool BfTypeInstance::IsSpecializedByAutoCompleteMethod()
|
||||
{
|
||||
for (auto methodArg : mTypeGenericArguments)
|
||||
if (mGenericTypeInfo == NULL)
|
||||
return false;
|
||||
for (auto methodArg : mGenericTypeInfo->mTypeGenericArguments)
|
||||
{
|
||||
// If we are specialized by an autocompleted method reference
|
||||
if (methodArg->IsMethodRef())
|
||||
|
|
@ -1637,14 +1647,16 @@ bool BfGenericTypeInstance::IsSpecializedByAutoCompleteMethod()
|
|||
return false;
|
||||
}
|
||||
|
||||
bool BfGenericTypeInstance::IsNullable()
|
||||
bool BfTypeInstance::IsNullable()
|
||||
{
|
||||
return (mTypeDef == mContext->mCompiler->mNullableTypeDef);
|
||||
}
|
||||
|
||||
bool BfGenericTypeInstance::HasVarConstraints()
|
||||
bool BfTypeInstance::HasVarConstraints()
|
||||
{
|
||||
for (auto genericParam : mGenericParams)
|
||||
if (mGenericTypeInfo == NULL)
|
||||
return false;
|
||||
for (auto genericParam : mGenericTypeInfo->mGenericParams)
|
||||
{
|
||||
if (genericParam->mGenericParamFlags & BfGenericParamFlag_Var)
|
||||
return true;
|
||||
|
|
@ -1652,9 +1664,11 @@ bool BfGenericTypeInstance::HasVarConstraints()
|
|||
return false;
|
||||
}
|
||||
|
||||
bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef* activeTypeDef, BfModule* module)
|
||||
bool BfTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef* activeTypeDef, BfModule* module)
|
||||
{
|
||||
if (mGenericExtensionInfo == NULL)
|
||||
if (mGenericTypeInfo == NULL)
|
||||
return true;
|
||||
if (mGenericTypeInfo->mGenericExtensionInfo == NULL)
|
||||
return true;
|
||||
if ((typeDef == NULL) || (typeDef == activeTypeDef))
|
||||
return true;
|
||||
|
|
@ -1666,10 +1680,10 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
|
|||
return true;
|
||||
|
||||
BfGenericExtensionEntry* genericExEntry = NULL;
|
||||
if (!mGenericExtensionInfo->mExtensionMap.TryGetValue(typeDef, &genericExEntry))
|
||||
if (!mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(typeDef, &genericExEntry))
|
||||
return true;
|
||||
|
||||
if (mIsUnspecialized)
|
||||
if (mGenericTypeInfo->mIsUnspecialized)
|
||||
{
|
||||
if (module == NULL)
|
||||
return true; // During population
|
||||
|
|
@ -1678,7 +1692,7 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
|
|||
|
||||
for (int genericIdx = 0; genericIdx < (int)declConstraints->size(); genericIdx++)
|
||||
{
|
||||
auto genericType = mTypeGenericArguments[genericIdx];
|
||||
auto genericType = mGenericTypeInfo->mTypeGenericArguments[genericIdx];
|
||||
|
||||
auto declGenericParam = (*declConstraints)[genericIdx];
|
||||
if (!module->CheckGenericConstraints(BfGenericParamSource(), genericType, NULL, declGenericParam))
|
||||
|
|
@ -1719,10 +1733,9 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
|
|||
return genericExEntry->mConstraintsPassed;
|
||||
}
|
||||
|
||||
void BfGenericTypeInstance::ReportMemory(MemReporter* memReporter)
|
||||
void BfGenericTypeInfo::ReportMemory(MemReporter* memReporter)
|
||||
{
|
||||
BfTypeInstance::ReportMemory(memReporter);
|
||||
memReporter->Add(sizeof(BfGenericTypeInstance) - sizeof(BfTypeInstance));
|
||||
memReporter->Add(sizeof(BfGenericTypeInfo));
|
||||
memReporter->AddVec(mTypeGenericArgumentRefs, false);
|
||||
memReporter->AddVec(mTypeGenericArguments, false);
|
||||
memReporter->AddVec(mGenericParams, false);
|
||||
|
|
@ -1732,7 +1745,11 @@ void BfGenericTypeInstance::ReportMemory(MemReporter* memReporter)
|
|||
BfType* BfTypeInstance::GetUnderlyingType()
|
||||
{
|
||||
if (!mIsTypedPrimitive)
|
||||
{
|
||||
if (mGenericTypeInfo != NULL)
|
||||
return mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (mTypeInfoEx == NULL)
|
||||
mTypeInfoEx = new BfTypeInfoEx();
|
||||
|
|
@ -1976,62 +1993,6 @@ void BfTupleType::Finish()
|
|||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BfGenericTupleType::BfGenericTupleType()
|
||||
{
|
||||
mCreatedTypeDef = false;
|
||||
mSource = NULL;
|
||||
mTypeDef = NULL;
|
||||
}
|
||||
|
||||
BfGenericTupleType::~BfGenericTupleType()
|
||||
{
|
||||
if (mCreatedTypeDef)
|
||||
delete mTypeDef;
|
||||
delete mSource;
|
||||
}
|
||||
|
||||
void BfGenericTupleType::Init(BfProject* bfProject, BfTypeInstance* valueTypeInstance)
|
||||
{
|
||||
auto srcTypeDef = valueTypeInstance->mTypeDef;
|
||||
auto system = valueTypeInstance->mModule->mSystem;
|
||||
|
||||
if (mTypeDef == NULL)
|
||||
mTypeDef = new BfTypeDef();
|
||||
for (auto field : mTypeDef->mFields)
|
||||
delete field;
|
||||
mTypeDef->mFields.Clear();
|
||||
mTypeDef->mSystem = system;
|
||||
mTypeDef->mProject = bfProject;
|
||||
mTypeDef->mTypeCode = srcTypeDef->mTypeCode;
|
||||
mTypeDef->mName = system->mEmptyAtom;
|
||||
mTypeDef->mSystem = system;
|
||||
|
||||
mTypeDef->mHash = srcTypeDef->mHash;
|
||||
mTypeDef->mSignatureHash = srcTypeDef->mSignatureHash;
|
||||
mTypeDef->mTypeCode = BfTypeCode_Struct;
|
||||
|
||||
mCreatedTypeDef = true;
|
||||
}
|
||||
|
||||
BfFieldDef* BfGenericTupleType::AddField(const StringImpl& name)
|
||||
{
|
||||
return BfDefBuilder::AddField(mTypeDef, NULL, name);
|
||||
}
|
||||
|
||||
void BfGenericTupleType::Finish()
|
||||
{
|
||||
auto bfSystem = mTypeDef->mSystem;
|
||||
mSource = new BfSource(bfSystem);
|
||||
mTypeDef->mSource = mSource;
|
||||
mTypeDef->mSource->mRefCount++;
|
||||
|
||||
BfDefBuilder bfDefBuilder(bfSystem);
|
||||
bfDefBuilder.mCurTypeDef = mTypeDef;
|
||||
bfDefBuilder.FinishTypeDef(true);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BfType* BfBoxedType::GetModifiedElementType()
|
||||
{
|
||||
if ((mBoxedFlags & BoxedFlags_StructPtr) != 0)
|
||||
|
|
@ -2210,7 +2171,7 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
|
|||
else if (type->IsArray())
|
||||
{
|
||||
BfArrayType* arrayType = (BfArrayType*)type;
|
||||
int elemHash = Hash(arrayType->mTypeGenericArguments[0], ctx) ^ (arrayType->mDimensions << 8);
|
||||
int elemHash = Hash(arrayType->mGenericTypeInfo->mTypeGenericArguments[0], ctx) ^ (arrayType->mDimensions << 8);
|
||||
return (elemHash << 5) - elemHash;
|
||||
}
|
||||
else if (type->IsDelegateFromTypeRef() || type->IsFunctionFromTypeRef())
|
||||
|
|
@ -2281,8 +2242,8 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
|
|||
}
|
||||
else if (type->IsGenericTypeInstance())
|
||||
{
|
||||
BfGenericTypeInstance* genericType = (BfGenericTypeInstance*)type;
|
||||
for (auto genericArg : genericType->mTypeGenericArguments)
|
||||
BfTypeInstance* genericType = (BfTypeInstance*)type;
|
||||
for (auto genericArg : genericType->mGenericTypeInfo->mTypeGenericArguments)
|
||||
hashVal = ((hashVal ^ (Hash(genericArg, ctx))) << 5) - hashVal;
|
||||
}
|
||||
return hashVal;
|
||||
|
|
@ -2428,11 +2389,11 @@ int BfResolvedTypeSet::Hash(BfTypeReference* typeRef, LookupContext* ctx, BfHash
|
|||
}
|
||||
|
||||
BF_ASSERT(checkTypeInstance->IsGenericTypeInstance());
|
||||
auto curGenericTypeInst = (BfGenericTypeInstance*)checkTypeInstance;
|
||||
auto curGenericTypeInst = (BfTypeInstance*)checkTypeInstance;
|
||||
int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size();
|
||||
for (int i = 0; i < numParentGenericParams; i++)
|
||||
{
|
||||
hashVal = ((hashVal ^ (Hash(curGenericTypeInst->mTypeGenericArguments[i], ctx))) << 5) - hashVal;
|
||||
hashVal = ((hashVal ^ (Hash(curGenericTypeInst->mGenericTypeInfo->mTypeGenericArguments[i], ctx))) << 5) - hashVal;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2501,10 +2462,10 @@ int BfResolvedTypeSet::Hash(BfTypeReference* typeRef, LookupContext* ctx, BfHash
|
|||
BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType);
|
||||
if (commonOuterType != NULL)
|
||||
{
|
||||
auto parentTypeInstance = (BfGenericTypeInstance*)ctx->mModule->mCurTypeInstance;
|
||||
auto parentTypeInstance = (BfTypeInstance*)ctx->mModule->mCurTypeInstance;
|
||||
int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size();
|
||||
for (int i = 0; i < numParentGenericParams; i++)
|
||||
hashVal = ((hashVal ^ (Hash(parentTypeInstance->mTypeGenericArguments[i], ctx))) << 5) - hashVal;
|
||||
hashVal = ((hashVal ^ (Hash(parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i], ctx))) << 5) - hashVal;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2837,7 +2798,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfType* rhs, LookupContext* ctx)
|
|||
BfArrayType* rhsArrayType = (BfArrayType*) rhs;
|
||||
if (lhsArrayType->mDimensions != rhsArrayType->mDimensions)
|
||||
return false;
|
||||
return Equals(lhsArrayType->mTypeGenericArguments[0], rhsArrayType->mTypeGenericArguments[0], ctx);
|
||||
return Equals(lhsArrayType->mGenericTypeInfo->mTypeGenericArguments[0], rhsArrayType->mGenericTypeInfo->mTypeGenericArguments[0], ctx);
|
||||
}
|
||||
else if (lhs->IsTypeInstance())
|
||||
{
|
||||
|
|
@ -2925,15 +2886,15 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfType* rhs, LookupContext* ctx)
|
|||
{
|
||||
if (!rhs->IsGenericTypeInstance())
|
||||
return false;
|
||||
BfGenericTypeInstance* lhsGenericType = (BfGenericTypeInstance*)lhs;
|
||||
BfGenericTypeInstance* rhsGenericType = (BfGenericTypeInstance*)rhs;
|
||||
if (lhsGenericType->mTypeGenericArguments.size() != rhsGenericType->mTypeGenericArguments.size())
|
||||
BfTypeInstance* lhsGenericType = (BfTypeInstance*)lhs;
|
||||
BfTypeInstance* rhsGenericType = (BfTypeInstance*)rhs;
|
||||
if (lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size() != rhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size())
|
||||
return false;
|
||||
if (lhsGenericType->mTypeDef != rhsGenericType->mTypeDef)
|
||||
return false;
|
||||
for (int i = 0; i < (int)lhsGenericType->mTypeGenericArguments.size(); i++)
|
||||
for (int i = 0; i < (int)lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); i++)
|
||||
{
|
||||
if (!Equals(lhsGenericType->mTypeGenericArguments[i], rhsGenericType->mTypeGenericArguments[i], ctx))
|
||||
if (!Equals(lhsGenericType->mGenericTypeInfo->mTypeGenericArguments[i], rhsGenericType->mGenericTypeInfo->mTypeGenericArguments[i], ctx))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -3027,7 +2988,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfType* rhs, LookupContext* ctx)
|
|||
return 0;
|
||||
}
|
||||
|
||||
bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset)
|
||||
bool BfResolvedTypeSet::GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset)
|
||||
{
|
||||
//BP_ZONE("BfResolvedTypeSet::GenericTypeEquals");
|
||||
|
||||
|
|
@ -3059,7 +3020,7 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
|
|||
return true;
|
||||
}
|
||||
|
||||
bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx)
|
||||
bool BfResolvedTypeSet::GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx)
|
||||
{
|
||||
auto rhsGenericTypeInstRef = BfNodeDynCastExact<BfGenericInstanceTypeRef>(rhs);
|
||||
if (rhsGenericTypeInstRef == NULL)
|
||||
|
|
@ -3072,7 +3033,7 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
|
|||
return false;
|
||||
|
||||
auto rhsElemType = ctx->mModule->ResolveTypeRef(rhsNullableTypeRef->mElementType, BfPopulateType_Identity, ctx->mResolveFlags);
|
||||
return lhsGenericType->mTypeGenericArguments[0] == rhsElemType;
|
||||
return lhsGenericType->mGenericTypeInfo->mTypeGenericArguments[0] == rhsElemType;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3089,11 +3050,11 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
|
|||
checkTypeInstance = checkTypeInstance->GetUnderlyingType()->ToTypeInstance();
|
||||
BF_ASSERT(checkTypeInstance->IsGenericTypeInstance());
|
||||
int numParentGenericParams = (int) commonOuterType->mGenericParamDefs.size();
|
||||
auto curTypeInstance = (BfGenericTypeInstance*)checkTypeInstance;
|
||||
if (lhsGenericType->mTypeGenericArguments.size() != numParentGenericParams)
|
||||
auto curTypeInstance = (BfTypeInstance*)checkTypeInstance;
|
||||
if (lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size() != numParentGenericParams)
|
||||
return false;
|
||||
for (int i = 0; i < (int) numParentGenericParams; i++)
|
||||
if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mTypeGenericArguments[i])
|
||||
if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -3120,12 +3081,12 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
|
|||
BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType);
|
||||
if (commonOuterType != NULL)
|
||||
{
|
||||
auto parentTypeInstance = (BfGenericTypeInstance*)ctx->mModule->mCurTypeInstance;
|
||||
auto parentTypeInstance = (BfTypeInstance*)ctx->mModule->mCurTypeInstance;
|
||||
genericParamOffset = (int) commonOuterType->mGenericParamDefs.size();
|
||||
for (int i = 0; i < genericParamOffset; i++)
|
||||
for (auto genericArg : parentTypeInstance->mTypeGenericArguments)
|
||||
for (auto genericArg : parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
|
||||
{
|
||||
if (parentTypeInstance->mTypeGenericArguments[i] != (*lhsTypeGenericArguments)[i])
|
||||
if (parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i] != (*lhsTypeGenericArguments)[i])
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -3193,7 +3154,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
|
|||
}
|
||||
}
|
||||
|
||||
if ((rhs->IsNamedTypeReference()) || (rhs->IsA<BfGenericInstanceTypeRef>()))
|
||||
if ((rhs->IsNamedTypeReference()) || (rhs->IsA<BfGenericInstanceTypeRef>()) || (rhs->IsA<BfQualifiedTypeReference>()))
|
||||
{
|
||||
if ((ctx->mRootTypeRef != rhs) || (ctx->mRootTypeDef == NULL))
|
||||
{
|
||||
|
|
@ -3235,7 +3196,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
|
|||
BfArrayType* lhsArrayType = (BfArrayType*) lhs;
|
||||
if (lhsArrayType->mDimensions != rhsArrayTypeRef->mDimensions)
|
||||
return false;
|
||||
return Equals(lhsArrayType->mTypeGenericArguments[0], rhsArrayTypeRef->mElementType, ctx);
|
||||
return Equals(lhsArrayType->mGenericTypeInfo->mTypeGenericArguments[0], rhsArrayTypeRef->mElementType, ctx);
|
||||
}
|
||||
else if (lhs->IsDelegateFromTypeRef() || lhs->IsFunctionFromTypeRef())
|
||||
{
|
||||
|
|
@ -3319,8 +3280,8 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
|
|||
if (rhsType != NULL)
|
||||
return lhs == rhsType;
|
||||
|
||||
BfGenericTypeInstance* lhsGenericType = (BfGenericTypeInstance*) lhs;
|
||||
return GenericTypeEquals(lhsGenericType, &lhsGenericType->mTypeGenericArguments, rhs, rhsTypeDef, ctx);
|
||||
BfTypeInstance* lhsGenericType = (BfTypeInstance*) lhs;
|
||||
return GenericTypeEquals(lhsGenericType, &lhsGenericType->mGenericTypeInfo->mTypeGenericArguments, rhs, rhsTypeDef, ctx);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -375,7 +375,7 @@ public:
|
|||
|
||||
class BfDependedType;
|
||||
class BfTypeInstance;
|
||||
class BfGenericTypeInstance;
|
||||
class BfTypeInstance;
|
||||
class BfPrimitiveType;
|
||||
|
||||
enum BfTypeRebuildFlags
|
||||
|
|
@ -466,7 +466,7 @@ public:
|
|||
|
||||
virtual BfDependedType* ToDependedType() { return NULL; }
|
||||
virtual BfTypeInstance* ToTypeInstance() { return NULL; }
|
||||
virtual BfGenericTypeInstance* ToGenericTypeInstance() { return NULL; }
|
||||
virtual BfTypeInstance* ToGenericTypeInstance() { return NULL; }
|
||||
virtual BfPrimitiveType* ToPrimitiveType() { return NULL; }
|
||||
virtual bool IsDependendType() { return false; }
|
||||
virtual bool IsTypeInstance() { return false; }
|
||||
|
|
@ -1610,6 +1610,66 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
|
||||
class BfGenericExtensionEntry
|
||||
{
|
||||
public:
|
||||
Array<BfGenericTypeParamInstance*> mGenericParams;
|
||||
bool mConstraintsPassed;
|
||||
|
||||
public:
|
||||
BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) :
|
||||
mGenericParams(std::move(prev.mGenericParams)),
|
||||
mConstraintsPassed(prev.mConstraintsPassed)
|
||||
{
|
||||
}
|
||||
|
||||
BfGenericExtensionEntry()
|
||||
{
|
||||
mConstraintsPassed = true;
|
||||
}
|
||||
~BfGenericExtensionEntry();
|
||||
};
|
||||
|
||||
class BfGenericExtensionInfo
|
||||
{
|
||||
public:
|
||||
Dictionary<BfTypeDef*, BfGenericExtensionEntry> mExtensionMap;
|
||||
};
|
||||
|
||||
// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so
|
||||
// class ClassA<T> { class ClassB<T2> {} } will create a ClassA.ClassB<T, T2>
|
||||
class BfGenericTypeInfo
|
||||
{
|
||||
public:
|
||||
typedef Array<BfGenericTypeParamInstance*> GenericParamsVector;
|
||||
|
||||
Array<BfTypeReference*> mTypeGenericArgumentRefs;
|
||||
BfTypeVector mTypeGenericArguments;
|
||||
GenericParamsVector mGenericParams;
|
||||
BfGenericExtensionInfo* mGenericExtensionInfo;
|
||||
bool mIsUnspecialized;
|
||||
bool mIsUnspecializedVariation;
|
||||
bool mValidatedGenericConstraints;
|
||||
bool mHadValidateErrors;
|
||||
Array<BfProject*> mProjectsReferenced; // Generic methods that only refer to these projects don't need a specialized extension
|
||||
|
||||
public:
|
||||
BfGenericTypeInfo()
|
||||
{
|
||||
mGenericExtensionInfo = NULL;
|
||||
mHadValidateErrors = false;
|
||||
mIsUnspecialized = false;
|
||||
mIsUnspecializedVariation = false;
|
||||
mValidatedGenericConstraints = false;
|
||||
}
|
||||
|
||||
~BfGenericTypeInfo();
|
||||
|
||||
void ReportMemory(MemReporter* memReporter);
|
||||
};
|
||||
|
||||
|
||||
// Instance of struct or class
|
||||
class BfTypeInstance : public BfDependedType
|
||||
{
|
||||
|
|
@ -1625,6 +1685,7 @@ public:
|
|||
BfCustomAttributes* mCustomAttributes;
|
||||
BfAttributeData* mAttributeData;
|
||||
BfTypeInfoEx* mTypeInfoEx;
|
||||
BfGenericTypeInfo* mGenericTypeInfo;
|
||||
|
||||
Array<BfTypeInterfaceEntry> mInterfaces;
|
||||
Array<BfTypeInterfaceMethodEntry> mInterfaceMethodTable;
|
||||
|
|
@ -1690,6 +1751,7 @@ public:
|
|||
mCustomAttributes = NULL;
|
||||
mAttributeData = NULL;
|
||||
mTypeInfoEx = NULL;
|
||||
mGenericTypeInfo = NULL;
|
||||
//mClassVData = NULL;
|
||||
mVirtualMethodTableSize = 0;
|
||||
mHotTypeData = NULL;
|
||||
|
|
@ -1767,6 +1829,18 @@ public:
|
|||
virtual bool WantsGCMarking() override;
|
||||
virtual BfTypeCode GetLoweredType() override;
|
||||
|
||||
BfGenericTypeInfo* GetGenericTypeInfo() { return mGenericTypeInfo; }
|
||||
|
||||
virtual BfTypeInstance* ToGenericTypeInstance() { return (mGenericTypeInfo != NULL) ? this : NULL; }
|
||||
virtual bool IsGenericTypeInstance() override { return mGenericTypeInfo != NULL; }
|
||||
virtual bool IsSpecializedType() override { return (mGenericTypeInfo != NULL) && (!mGenericTypeInfo->mIsUnspecialized); }
|
||||
virtual bool IsSpecializedByAutoCompleteMethod() override;
|
||||
virtual bool IsUnspecializedType() override { return (mGenericTypeInfo != NULL) && (mGenericTypeInfo->mIsUnspecialized); }
|
||||
virtual bool IsUnspecializedTypeVariation() override { return (mGenericTypeInfo != NULL) && (mGenericTypeInfo->mIsUnspecializedVariation); }
|
||||
virtual bool IsNullable() override;
|
||||
virtual bool HasVarConstraints();
|
||||
virtual bool IsTypeMemberIncluded(BfTypeDef* declaringTypeDef, BfTypeDef* activeTypeDef = NULL, BfModule* module = NULL) override;
|
||||
|
||||
virtual BfTypeInstance* GetImplBaseType() { return mBaseType; }
|
||||
|
||||
virtual bool IsIRFuncUsed(BfIRFunction func);
|
||||
|
|
@ -1786,6 +1860,8 @@ public:
|
|||
int GetInstStride() { return BF_ALIGN(mInstSize, mInstAlign); }
|
||||
bool HasOverrideMethods();
|
||||
bool GetResultInfo(BfType*& valueType, int& okTagId);
|
||||
BfGenericTypeInfo::GenericParamsVector* GetGenericParamsVector(BfTypeDef* declaringTypeDef);
|
||||
void GenerateProjectsReferenced();
|
||||
|
||||
virtual void ReportMemory(MemReporter* memReporter) override;
|
||||
};
|
||||
|
|
@ -1856,7 +1932,7 @@ public:
|
|||
virtual bool IsDependentOnUnderlyingType() override { return true; }
|
||||
virtual BfType* GetUnderlyingType() override { return mElementType; }
|
||||
|
||||
virtual BfGenericTypeInstance* ToGenericTypeInstance() override { return mElementType->ToGenericTypeInstance(); }
|
||||
virtual BfTypeInstance* ToGenericTypeInstance() override { return mElementType->ToGenericTypeInstance(); }
|
||||
virtual bool IsSpecializedType() override { return !mElementType->IsUnspecializedType(); }
|
||||
virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); }
|
||||
virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedTypeVariation(); }
|
||||
|
|
@ -1871,79 +1947,6 @@ public:
|
|||
BfType* GetModifiedElementType();
|
||||
};
|
||||
|
||||
class BfGenericExtensionEntry
|
||||
{
|
||||
public:
|
||||
Array<BfGenericTypeParamInstance*> mGenericParams;
|
||||
bool mConstraintsPassed;
|
||||
|
||||
public:
|
||||
BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) :
|
||||
mGenericParams(std::move(prev.mGenericParams)),
|
||||
mConstraintsPassed(prev.mConstraintsPassed)
|
||||
{
|
||||
}
|
||||
|
||||
BfGenericExtensionEntry()
|
||||
{
|
||||
mConstraintsPassed = true;
|
||||
}
|
||||
~BfGenericExtensionEntry();
|
||||
};
|
||||
|
||||
class BfGenericExtensionInfo
|
||||
{
|
||||
public:
|
||||
Dictionary<BfTypeDef*, BfGenericExtensionEntry> mExtensionMap;
|
||||
};
|
||||
|
||||
// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so
|
||||
// class ClassA<T> { class ClassB<T2> {} } will create a ClassA.ClassB<T, T2>
|
||||
class BfGenericTypeInstance : public BfTypeInstance
|
||||
{
|
||||
public:
|
||||
typedef Array<BfGenericTypeParamInstance*> GenericParamsVector;
|
||||
|
||||
Array<BfTypeReference*> mTypeGenericArgumentRefs;
|
||||
BfTypeVector mTypeGenericArguments;
|
||||
GenericParamsVector mGenericParams;
|
||||
BfGenericExtensionInfo* mGenericExtensionInfo;
|
||||
bool mIsUnspecialized;
|
||||
bool mIsUnspecializedVariation;
|
||||
bool mValidatedGenericConstraints;
|
||||
bool mHadValidateErrors;
|
||||
Array<BfProject*> mProjectsReferenced; // Generic methods that only refer to these projects don't need a specialized extension
|
||||
|
||||
public:
|
||||
BfGenericTypeInstance()
|
||||
{
|
||||
mGenericExtensionInfo = NULL;
|
||||
mHadValidateErrors = false;
|
||||
mIsUnspecialized = false;
|
||||
mIsUnspecializedVariation = false;
|
||||
mValidatedGenericConstraints = false;
|
||||
}
|
||||
|
||||
~BfGenericTypeInstance();
|
||||
|
||||
GenericParamsVector* GetGenericParamsVector(BfTypeDef* declaringTypeDef);
|
||||
void GenerateProjectsReferenced();
|
||||
|
||||
virtual BfGenericTypeInstance* ToGenericTypeInstance() override { return this; }
|
||||
|
||||
virtual bool IsGenericTypeInstance() override { return true; }
|
||||
virtual bool IsSpecializedType() override { return !mIsUnspecialized; }
|
||||
virtual bool IsSpecializedByAutoCompleteMethod() override;
|
||||
virtual bool IsUnspecializedType() override { return mIsUnspecialized; }
|
||||
virtual bool IsUnspecializedTypeVariation() override { return mIsUnspecializedVariation; }
|
||||
virtual bool IsNullable() override;
|
||||
virtual bool HasVarConstraints();
|
||||
virtual BfType* GetUnderlyingType() override { return mIsTypedPrimitive ? BfTypeInstance::GetUnderlyingType() : mTypeGenericArguments[0]; }
|
||||
virtual bool IsTypeMemberIncluded(BfTypeDef* declaringTypeDef, BfTypeDef* activeTypeDef, BfModule* module) override;
|
||||
|
||||
virtual void ReportMemory(MemReporter* memReporter) override;
|
||||
};
|
||||
|
||||
class BfTypeAliasType : public BfTypeInstance
|
||||
{
|
||||
public:
|
||||
|
|
@ -1957,22 +1960,6 @@ public:
|
|||
|
||||
virtual bool IsTypeAlias() override { return true; }
|
||||
virtual BfType* GetUnderlyingType() override { return mAliasToType; }
|
||||
};
|
||||
|
||||
class BfGenericTypeAliasType : public BfGenericTypeInstance
|
||||
{
|
||||
public:
|
||||
BfType* mAliasToType;
|
||||
|
||||
public:
|
||||
BfGenericTypeAliasType()
|
||||
{
|
||||
mAliasToType = NULL;
|
||||
}
|
||||
|
||||
virtual bool IsTypeAlias() override { return true; }
|
||||
virtual BfType* GetUnderlyingType() override { return mAliasToType; }
|
||||
|
||||
virtual bool WantsGCMarking() override { return mAliasToType->WantsGCMarking(); }
|
||||
};
|
||||
|
||||
|
|
@ -2036,28 +2023,6 @@ public:
|
|||
virtual BfDelegateInfo* GetDelegateInfo() { return &mDelegateInfo; }
|
||||
};
|
||||
|
||||
class BfGenericDelegateType : public BfGenericTypeInstance
|
||||
{
|
||||
public:
|
||||
BfDelegateInfo mDelegateInfo;
|
||||
|
||||
public:
|
||||
BfGenericDelegateType()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
virtual bool IsOnDemand() override { return true; }
|
||||
|
||||
virtual bool IsDelegate() override { return mTypeDef->mIsDelegate; }
|
||||
virtual bool IsDelegateFromTypeRef() override { return mTypeDef->mIsDelegate; }
|
||||
|
||||
virtual bool IsFunction() override { return !mTypeDef->mIsDelegate; }
|
||||
virtual bool IsFunctionFromTypeRef() override { return !mTypeDef->mIsDelegate; }
|
||||
|
||||
virtual BfDelegateInfo* GetDelegateInfo() override { return &mDelegateInfo; }
|
||||
};
|
||||
|
||||
class BfTupleType : public BfTypeInstance
|
||||
{
|
||||
public:
|
||||
|
|
@ -2082,25 +2047,6 @@ public:
|
|||
virtual bool IsUnspecializedTypeVariation() override { return mIsUnspecializedTypeVariation; }
|
||||
};
|
||||
|
||||
class BfGenericTupleType : public BfGenericTypeInstance
|
||||
{
|
||||
public:
|
||||
bool mCreatedTypeDef;
|
||||
String mNameAdd;
|
||||
BfSource* mSource;
|
||||
|
||||
public:
|
||||
BfGenericTupleType();
|
||||
~BfGenericTupleType();
|
||||
|
||||
void Init(BfProject* bfProject, BfTypeInstance* valueTypeInstance);
|
||||
BfFieldDef* AddField(const StringImpl& name);
|
||||
void Finish();
|
||||
|
||||
virtual bool IsOnDemand() override { return true; }
|
||||
virtual bool IsTuple() override { return true; }
|
||||
};
|
||||
|
||||
class BfConcreteInterfaceType : public BfType
|
||||
{
|
||||
public:
|
||||
|
|
@ -2213,7 +2159,7 @@ public:
|
|||
virtual bool IsValuelessType() override { return mElementType->IsValuelessType(); }
|
||||
};
|
||||
|
||||
class BfArrayType : public BfGenericTypeInstance
|
||||
class BfArrayType : public BfTypeInstance
|
||||
{
|
||||
public:
|
||||
int mDimensions;
|
||||
|
|
@ -2391,8 +2337,8 @@ public:
|
|||
|
||||
public:
|
||||
static BfVariant EvaluateToVariant(LookupContext* ctx, BfExpression* expr, BfType*& constGenericParam);
|
||||
static bool GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset);
|
||||
static bool GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* typeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx);
|
||||
static bool GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset);
|
||||
static bool GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* typeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx);
|
||||
static void HashGenericArguments(BfTypeReference* typeRef, LookupContext* ctx, int& hash);
|
||||
static int Hash(BfType* type, LookupContext* ctx, bool allowRef = false);
|
||||
static int DirectHash(BfTypeReference* typeRef, LookupContext* ctx, BfHashFlags flags = BfHashFlag_None);
|
||||
|
|
@ -2483,7 +2429,7 @@ public:
|
|||
auto genericTypeInst = typeInst->ToGenericTypeInstance();
|
||||
if (genericTypeInst != NULL)
|
||||
{
|
||||
for (auto genericArg : genericTypeInst->mTypeGenericArguments)
|
||||
for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
|
||||
GetProjectList(genericArg, projectList, immutableLength);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5845,10 +5845,10 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
|
|||
|
||||
if (genericParamInst->mTypeConstraint->IsGenericTypeInstance())
|
||||
{
|
||||
auto genericConstraintType = (BfGenericTypeInstance*)genericParamInst->mTypeConstraint;
|
||||
auto genericConstraintType = (BfTypeInstance*)genericParamInst->mTypeConstraint;
|
||||
if (genericConstraintType->mTypeDef == mCompiler->mSizedArrayTypeDef)
|
||||
{
|
||||
varType = genericConstraintType->mTypeGenericArguments[0];
|
||||
varType = genericConstraintType->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
isVarEnumerator = true;
|
||||
}
|
||||
}
|
||||
|
|
@ -5909,7 +5909,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
|
|||
{
|
||||
PopulateType(itr.mType, BfPopulateType_DataAndMethods);
|
||||
|
||||
BfGenericTypeInstance* genericItrInterface = NULL;
|
||||
BfTypeInstance* genericItrInterface = NULL;
|
||||
|
||||
auto _CheckInterface = [&](BfTypeInstance* interface)
|
||||
{
|
||||
|
|
@ -5924,7 +5924,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
|
|||
genericItrInterface = itrInterface->ToGenericTypeInstance();
|
||||
if (inferVarType)
|
||||
{
|
||||
varType = genericItrInterface->mTypeGenericArguments[0];
|
||||
varType = genericItrInterface->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
if (isRefExpression)
|
||||
{
|
||||
if (varType->IsPointer())
|
||||
|
|
@ -5950,7 +5950,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
|
|||
genericItrInterface = itrInterface->ToGenericTypeInstance();
|
||||
if (inferVarType)
|
||||
{
|
||||
varType = genericItrInterface->mTypeGenericArguments[0];
|
||||
varType = genericItrInterface->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
if (isRefExpression)
|
||||
{
|
||||
if (varType->IsPointer())
|
||||
|
|
@ -6093,7 +6093,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
|
|||
|
||||
if (nextResult.mType->IsGenericTypeInstance())
|
||||
{
|
||||
nextEmbeddedType = ((BfGenericTypeInstance*)nextResult.mType)->mTypeGenericArguments[0];
|
||||
nextEmbeddedType = ((BfTypeInstance*)nextResult.mType)->mGenericTypeInfo->mTypeGenericArguments[0];
|
||||
}
|
||||
}
|
||||
if (nextEmbeddedType == NULL)
|
||||
|
|
|
|||
|
|
@ -86,8 +86,8 @@ DwMethodMatcher::DwMethodMatcher(BfAstNode* targetSrc, DbgExprEvaluator* exprEva
|
|||
{
|
||||
if (!argType->IsGenericTypeInstance())
|
||||
return true;
|
||||
auto wantGenericType = (BfGenericTypeInstance*)wantType;
|
||||
auto argGenericType = (BfGenericTypeInstance*)argType;
|
||||
auto wantGenericType = (BfTypeInstance*)wantType;
|
||||
auto argGenericType = (BfTypeInstance*)argType;
|
||||
if (argGenericType->mTypeDef != wantGenericType->mTypeDef)
|
||||
return true;
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,9 @@ namespace Tests
|
|||
public typealias AliasA5 = (int, T);
|
||||
public typealias AliasA6<T2> = (T, T2);
|
||||
|
||||
public typealias AliasA7 = T[];
|
||||
public typealias AliasA8 = T[3];
|
||||
|
||||
public delegate T Zag();
|
||||
}
|
||||
|
||||
|
|
@ -31,6 +34,10 @@ namespace Tests
|
|||
|
||||
ClassA<T>.AliasA6<float> t0 = (default(T), 1.2f);
|
||||
ClassA<T>.AliasA4<int16> dlg0 = scope => LocalA;
|
||||
|
||||
ClassA<T>.AliasA7 arr0 = scope T[123];
|
||||
T[3] arr1 = .(default, default, default);
|
||||
ClassA<T>.AliasA8 arr2 = arr1;
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue