Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-08 03:28:20 +02:00
Code Activity

Refactored generic type instances to be a BfGenericTypeInfo member

Browse source
This commit is contained in:
Brian Fiete 2020-06-05 07:01:58 -07:00
parent 5d9a5f183d
commit 9f00539d90
16 changed files with 504 additions and 578 deletions
Download patch file Download diff file Expand all files Collapse all files

4
IDEHelper/Compiler/BfAutoComplete.cpp
View file

@ -1540,10 +1540,10 @@ bool BfAutoComplete::CheckMemberReference(BfAstNode* target, BfAstNode* dotToken
// ?. should look inside nullable types // ?. should look inside nullable types
if (targetValue.mType->IsNullable()) if (targetValue.mType->IsNullable())
{ {
BfGenericTypeInstance* nullableType = (BfGenericTypeInstance*)targetValue.mType->ToTypeInstance(); BfTypeInstance* nullableType = (BfTypeInstance*)targetValue.mType->ToTypeInstance();
targetValue = mModule->MakeAddressable(targetValue); targetValue = mModule->MakeAddressable(targetValue);
BfIRValue valuePtr = mModule->mBfIRBuilder->CreateInBoundsGEP(targetValue.mValue, 0, 1); // mValue 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);
} }
} }
} }

28
IDEHelper/Compiler/BfCompiler.cpp
View file

@ -466,7 +466,7 @@ bool BfCompiler::IsTypeAccessible(BfType* checkType, BfProject* curProject)
auto genericTypeInst = typeInst->ToGenericTypeInstance(); auto genericTypeInst = typeInst->ToGenericTypeInstance();
if (genericTypeInst != NULL) if (genericTypeInst != NULL)
{ {
for (auto genericArg : genericTypeInst->mTypeGenericArguments) for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
if (!IsTypeAccessible(genericArg, curProject)) if (!IsTypeAccessible(genericArg, curProject))
return false; return false;
} }
@ -515,7 +515,7 @@ bool BfCompiler::IsTypeUsed(BfType* checkType, BfProject* curProject)
auto genericTypeInst = typeInst->ToGenericTypeInstance(); auto genericTypeInst = typeInst->ToGenericTypeInstance();
if (genericTypeInst != NULL) if (genericTypeInst != NULL)
{ {
for (auto genericArg : genericTypeInst->mTypeGenericArguments) for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
if (!IsTypeUsed(genericArg, curProject)) if (!IsTypeUsed(genericArg, curProject))
return false; return false;
} }
@ -3858,9 +3858,9 @@ void BfCompiler::ProcessAutocompleteTempType()
if ((tempTypeDef->IsExtension()) && (actualTypeDef->mIsCombinedPartial) && (typeInst->IsGenericTypeInstance())) if ((tempTypeDef->IsExtension()) && (actualTypeDef->mIsCombinedPartial) && (typeInst->IsGenericTypeInstance()))
{ {
// Add to our extension info map and then take it out at the end... // 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); module->BuildGenericExtensionInfo(genericTypeInst, tempTypeDef);
genericTypeInst->mGenericExtensionInfo->mExtensionMap.TryGetValue(tempTypeDef, &genericExEntry); genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(tempTypeDef, &genericExEntry);
BF_ASSERT(genericExEntry != NULL); BF_ASSERT(genericExEntry != NULL);
hadTempExtensionInfo = true; hadTempExtensionInfo = true;
} }
@ -4195,8 +4195,8 @@ void BfCompiler::ProcessAutocompleteTempType()
if (hadTempExtensionInfo) if (hadTempExtensionInfo)
{ {
auto genericTypeInst = (BfGenericTypeInstance*)typeInst; auto genericTypeInst = (BfTypeInstance*)typeInst;
genericTypeInst->mGenericExtensionInfo->mExtensionMap.Remove(tempTypeDef); genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.Remove(tempTypeDef);
} }
for (auto checkNode : mResolvePassData->mExteriorAutocompleteCheckNodes) for (auto checkNode : mResolvePassData->mExteriorAutocompleteCheckNodes)
@ -4478,9 +4478,9 @@ void BfCompiler::GetSymbolReferences()
{ {
if (rebuildTypeInst->IsGenericTypeInstance()) 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); BfGenericTypeParamInstance genericParamInstance(genericTypeInstance->mTypeDef, genericParamIdx);
auto genericParamDef = typeDef->mGenericParamDefs[genericParamIdx]; auto genericParamDef = typeDef->mGenericParamDefs[genericParamIdx];
@ -4967,7 +4967,7 @@ void BfCompiler::PopulateReified()
auto typeInst = type->ToTypeInstance(); auto typeInst = type->ToTypeInstance();
if ((typeInst != NULL) && (typeInst->IsGenericTypeInstance()) && (!typeInst->IsUnspecializedType()) && if ((typeInst != NULL) && (typeInst->IsGenericTypeInstance()) && (!typeInst->IsUnspecializedType()) &&
(!typeInst->IsDelegateFromTypeRef()) && (!typeInst->IsFunctionFromTypeRef())) (!typeInst->IsDelegateFromTypeRef()) && (!typeInst->IsFunctionFromTypeRef()) && (!typeInst->IsTuple()))
{ {
auto unspecializedType = module->GetUnspecializedTypeInstance(typeInst); auto unspecializedType = module->GetUnspecializedTypeInstance(typeInst);
if (!unspecializedType->mIsReified) if (!unspecializedType->mIsReified)
@ -4977,7 +4977,7 @@ void BfCompiler::PopulateReified()
// Check reifications forced by virtuals or interfaces // Check reifications forced by virtuals or interfaces
if ((!mIsResolveOnly) && (typeInst != NULL) && (typeInst->mIsReified) && (typeInst->IsObject()) && (!typeInst->IsUnspecializedType()) if ((!mIsResolveOnly) && (typeInst != NULL) && (typeInst->mIsReified) && (typeInst->IsObject()) && (!typeInst->IsUnspecializedType())
&& (typeInst->mHasBeenInstantiated) && (!typeInst->IsIncomplete())) && (typeInst->mHasBeenInstantiated) && (!typeInst->IsIncomplete()))
{ {
// If we have chained methods, make sure we implement the chain members if the chain head is implemented and reified // If we have chained methods, make sure we implement the chain members if the chain head is implemented and reified
if (typeInst->mTypeDef->mIsCombinedPartial) if (typeInst->mTypeDef->mIsCombinedPartial)
{ {
@ -7302,16 +7302,16 @@ void BfCompiler::GenerateAutocompleteInfo()
} }
else else
{ {
BfGenericTypeInstance* genericType = methodEntry.mTypeInstance->ToGenericTypeInstance(); BfTypeInstance* genericType = methodEntry.mTypeInstance->ToGenericTypeInstance();
if (genericType == NULL) if (genericType == NULL)
{ {
if (methodEntry.mCurMethodInstance != NULL) if (methodEntry.mCurMethodInstance != NULL)
genericType = methodEntry.mCurMethodInstance->GetOwner()->ToGenericTypeInstance(); 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; methodText += genericParamInstance->GetGenericParamDef()->mName;
} }
else else
@ -8331,7 +8331,7 @@ BF_EXPORT const char* BF_CALLTYPE BfCompiler_GetTypeInfo(BfCompiler* bfCompiler,
outString += " TypeFailed"; outString += " TypeFailed";
if (auto genericTypeInst = typeInst->ToGenericTypeInstance()) if (auto genericTypeInst = typeInst->ToGenericTypeInstance())
{ {
if (genericTypeInst->mHadValidateErrors) if (genericTypeInst->mGenericTypeInfo->mHadValidateErrors)
outString += " ValidateErrors"; outString += " ValidateErrors";
} }
} }

2
IDEHelper/Compiler/BfConstResolver.cpp
View file

@ -258,7 +258,7 @@ bool BfConstResolver::PrepareMethodArguments(BfAstNode* targetSrc, BfMethodMatch
BfArrayType* arrayType = (BfArrayType*)wantType; BfArrayType* arrayType = (BfArrayType*)wantType;
if (arrayType->IsIncomplete()) if (arrayType->IsIncomplete())
mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods); mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods);
expandedParamsElementType = arrayType->mTypeGenericArguments[0]; expandedParamsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
continue; continue;
} }
} }

31
IDEHelper/Compiler/BfContext.cpp
View file

@ -265,6 +265,9 @@ void BfContext::QueueFinishModule(BfModule* module)
{ {
bool needsDefer = false; bool needsDefer = false;
BF_ASSERT(module != mScratchModule);
BF_ASSERT(module != mUnreifiedModule);
if (mCompiler->mMaxInterfaceSlots == -1) if (mCompiler->mMaxInterfaceSlots == -1)
{ {
if (module->mUsedSlotCount == 0) if (module->mUsedSlotCount == 0)
@ -791,7 +794,7 @@ void BfContext::ValidateDependencies()
// if ((type->IsGenericTypeInstance()) && (type->mDefineState > BfTypeDefineState_Undefined)) // if ((type->IsGenericTypeInstance()) && (type->mDefineState > BfTypeDefineState_Undefined))
// { // {
// // We can't contain deleted generic arguments without being deleted ourselves // // 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->mTypeGenericArguments)
// { // {
@ -1015,16 +1018,16 @@ void BfContext::RebuildType(BfType* type, bool deleteOnDemandTypes, bool rebuild
if (typeInst->IsGenericTypeInstance()) if (typeInst->IsGenericTypeInstance())
{ {
auto genericTypeInstance = (BfGenericTypeInstance*)typeInst; auto genericTypeInstance = (BfTypeInstance*)typeInst;
genericTypeInstance->mTypeGenericArgumentRefs.Clear(); genericTypeInstance->mGenericTypeInfo->mTypeGenericArgumentRefs.Clear();
for (auto genericParam : genericTypeInstance->mGenericParams) for (auto genericParam : genericTypeInstance->mGenericTypeInfo->mGenericParams)
genericParam->Release(); genericParam->Release();
genericTypeInstance->mGenericParams.Clear(); genericTypeInstance->mGenericTypeInfo->mGenericParams.Clear();
genericTypeInstance->mValidatedGenericConstraints = false; genericTypeInstance->mGenericTypeInfo->mValidatedGenericConstraints = false;
genericTypeInstance->mHadValidateErrors = false; genericTypeInstance->mGenericTypeInfo->mHadValidateErrors = false;
delete genericTypeInstance->mGenericExtensionInfo; delete genericTypeInstance->mGenericTypeInfo->mGenericExtensionInfo;
genericTypeInstance->mGenericExtensionInfo = NULL; genericTypeInstance->mGenericTypeInfo->mGenericExtensionInfo = NULL;
genericTypeInstance->mProjectsReferenced.Clear(); genericTypeInstance->mGenericTypeInfo->mProjectsReferenced.Clear();
} }
typeInst->mStaticSearchMap.Clear(); typeInst->mStaticSearchMap.Clear();
@ -1609,9 +1612,9 @@ void BfContext::UpdateAfterDeletingTypes()
if (type->IsGenericTypeInstance()) if (type->IsGenericTypeInstance())
{ {
// We can't contain deleted generic arguments without being deleted ourselves // 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())); 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++) 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); GenerateModuleName_Type(type, name);
} }
} }

8
IDEHelper/Compiler/BfContext.h
View file

@ -371,11 +371,10 @@ public:
BfAllocPool<BfUnknownSizedArrayType> mUnknownSizedArrayTypePool; BfAllocPool<BfUnknownSizedArrayType> mUnknownSizedArrayTypePool;
BfAllocPool<BfBoxedType> mBoxedTypePool; BfAllocPool<BfBoxedType> mBoxedTypePool;
BfAllocPool<BfTupleType> mTupleTypePool; BfAllocPool<BfTupleType> mTupleTypePool;
BfAllocPool<BfGenericTupleType> mGenericTupleTypePool; BfAllocPool<BfTypeAliasType> mAliasTypePool;
BfAllocPool<BfRefType> mRefTypePool; BfAllocPool<BfRefType> mRefTypePool;
BfAllocPool<BfModifiedTypeType> mRetTypeTypePool; BfAllocPool<BfModifiedTypeType> mRetTypeTypePool;
BfAllocPool<BfGenericTypeInstance> mGenericTypeInstancePool; BfAllocPool<BfTypeInstance> mGenericTypeInstancePool;
BfAllocPool<BfGenericTypeAliasType> mGenericTypeAliasPool;
BfAllocPool<BfArrayType> mArrayTypeInstancePool; BfAllocPool<BfArrayType> mArrayTypeInstancePool;
BfAllocPool<BfGenericParamType> mGenericParamTypePool; BfAllocPool<BfGenericParamType> mGenericParamTypePool;
BfAllocPool<BfDirectTypeDefReference> mTypeDefTypeRefPool; BfAllocPool<BfDirectTypeDefReference> mTypeDefTypeRefPool;
@ -383,8 +382,7 @@ public:
BfAllocPool<BfGenericInstanceTypeRef> mGenericTypeRefPool; BfAllocPool<BfGenericInstanceTypeRef> mGenericTypeRefPool;
BfAllocPool<BfConcreteInterfaceType> mConcreteInterfaceTypePool; BfAllocPool<BfConcreteInterfaceType> mConcreteInterfaceTypePool;
BfAllocPool<BfConstExprValueType> mConstExprValueTypePool; BfAllocPool<BfConstExprValueType> mConstExprValueTypePool;
BfAllocPool<BfDelegateType> mDelegateTypePool; BfAllocPool<BfDelegateType> mDelegateTypePool;
BfAllocPool<BfGenericDelegateType> mGenericDelegateTypePool;
BfPrimitiveType* mPrimitiveTypes[BfTypeCode_Length]; BfPrimitiveType* mPrimitiveTypes[BfTypeCode_Length];
BfPrimitiveType* mPrimitiveStructTypes[BfTypeCode_Length]; BfPrimitiveType* mPrimitiveStructTypes[BfTypeCode_Length];

70
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -255,18 +255,18 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
{ {
if (methodGenericTypeConstraint->IsGenericTypeInstance()) if (methodGenericTypeConstraint->IsGenericTypeInstance())
{ {
auto wantGenericType = (BfGenericTypeInstance*)methodGenericTypeConstraint; auto wantGenericType = (BfTypeInstance*)methodGenericTypeConstraint;
auto checkArgType = argType; auto checkArgType = argType;
while (checkArgType != NULL) while (checkArgType != NULL)
{ {
if (checkArgType->IsGenericTypeInstance()) if (checkArgType->IsGenericTypeInstance())
{ {
auto argGenericType = (BfGenericTypeInstance*)checkArgType; auto argGenericType = (BfTypeInstance*)checkArgType;
if (argGenericType->mTypeDef == wantGenericType->mTypeDef) if (argGenericType->mTypeDef == wantGenericType->mTypeDef)
{ {
for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mTypeGenericArguments.size(); genericArgIdx++) for (int genericArgIdx = 0; genericArgIdx < (int)argGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++)
InferGenericArgument(methodInstance, argGenericType->mTypeGenericArguments[genericArgIdx], wantGenericType->mTypeGenericArguments[genericArgIdx], BfIRValue()); InferGenericArgument(methodInstance, argGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], wantGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], BfIRValue());
} }
} }
else if (checkArgType->IsSizedArray()) else if (checkArgType->IsSizedArray())
@ -274,10 +274,10 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
auto sizedArrayType = (BfSizedArrayType*)checkArgType; auto sizedArrayType = (BfSizedArrayType*)checkArgType;
if (wantGenericType->mTypeDef == mModule->mCompiler->mSizedArrayTypeDef) 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); auto intType = mModule->GetPrimitiveType(BfTypeCode_IntPtr);
BfTypedValue arraySize = BfTypedValue(mModule->mBfIRBuilder->CreateConst(BfTypeCode_IntPtr, (uint64)sizedArrayType->mElementCount), intType); 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()) else if (checkArgType->IsPointer())
@ -285,7 +285,7 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
auto pointerType = (BfPointerType*)checkArgType; auto pointerType = (BfPointerType*)checkArgType;
if (wantGenericType->mTypeDef == mModule->mCompiler->mPointerTTypeDef) 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())) if ((wantType->IsGenericTypeInstance()) && (wantType->IsUnspecializedTypeVariation()))
{ {
auto wantGenericType = (BfGenericTypeInstance*)wantType; auto wantGenericType = (BfTypeInstance*)wantType;
if (argType->IsGenericParam()) if (argType->IsGenericParam())
{ {
auto genericParam = mModule->GetGenericParamInstance((BfGenericParamType*)argType); auto genericParam = mModule->GetGenericParamInstance((BfGenericParamType*)argType);
@ -405,9 +405,9 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
if (argType->IsVar()) 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()) if (!wantGenericArgument->IsUnspecializedType())
continue; continue;
InferGenericArgument(methodInstance, mModule->GetPrimitiveType(BfTypeCode_Var), wantGenericArgument, BfIRValue()); InferGenericArgument(methodInstance, mModule->GetPrimitiveType(BfTypeCode_Var), wantGenericArgument, BfIRValue());
@ -428,18 +428,18 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
if (!argType->IsGenericTypeInstance()) if (!argType->IsGenericTypeInstance())
return true; return true;
auto argGenericType = (BfGenericTypeInstance*)argType; auto argGenericType = (BfTypeInstance*)argType;
if (argGenericType->mTypeDef != wantGenericType->mTypeDef) if (argGenericType->mTypeDef != wantGenericType->mTypeDef)
return true; 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()) if (!wantGenericArgument->IsUnspecializedType())
continue; continue;
if (!_AddToCheckedSet(argType, mCheckedTypeSet, alreadyChecked)) if (!_AddToCheckedSet(argType, mCheckedTypeSet, alreadyChecked))
return true; return true;
InferGenericArgument(methodInstance, argGenericType->mTypeGenericArguments[genericArgIdx], wantGenericArgument, BfIRValue()); InferGenericArgument(methodInstance, argGenericType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx], wantGenericArgument, BfIRValue());
} }
return true; return true;
} }
@ -824,12 +824,12 @@ void BfMethodMatcher::CompareMethods(BfMethodInstance* prevMethodInstance, BfTyp
{ {
if ((newType->IsUnspecializedType()) && (newType->IsGenericTypeInstance())) if ((newType->IsUnspecializedType()) && (newType->IsGenericTypeInstance()))
{ {
BfGenericTypeInstance* newGenericType = (BfGenericTypeInstance*)newType; BfTypeInstance* newGenericType = (BfTypeInstance*)newType;
BfGenericTypeInstance* prevGenericType = (BfGenericTypeInstance*)prevType; 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(); auto owner = newMethodInstance->GetOwner();
if ((newMethodDef->mDeclaringType != prevMethodDef->mDeclaringType) && (owner->IsGenericTypeInstance())) if ((newMethodDef->mDeclaringType != prevMethodDef->mDeclaringType) && (owner->IsGenericTypeInstance()))
{ {
auto genericOwner = (BfGenericTypeInstance*)owner; auto genericOwner = (BfTypeInstance*)owner;
if (genericOwner->mGenericExtensionInfo != NULL) if (genericOwner->mGenericTypeInfo->mGenericExtensionInfo != NULL)
{ {
BfGenericExtensionEntry* newGenericExtesionEntry = NULL; BfGenericExtensionEntry* newGenericExtesionEntry = NULL;
BfGenericExtensionEntry* prevGenericExtesionEntry = NULL; BfGenericExtensionEntry* prevGenericExtesionEntry = NULL;
if ((genericOwner->mGenericExtensionInfo->mExtensionMap.TryGetValue(newMethodDef->mDeclaringType, &newGenericExtesionEntry)) && if ((genericOwner->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(newMethodDef->mDeclaringType, &newGenericExtesionEntry)) &&
(genericOwner->mGenericExtensionInfo->mExtensionMap.TryGetValue(prevMethodDef->mDeclaringType, &prevGenericExtesionEntry))) (genericOwner->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(prevMethodDef->mDeclaringType, &prevGenericExtesionEntry)))
{ {
if ((newGenericExtesionEntry->mGenericParams.size() == prevGenericExtesionEntry->mGenericParams.size())) if ((newGenericExtesionEntry->mGenericParams.size() == prevGenericExtesionEntry->mGenericParams.size()))
{ {
@ -1520,7 +1520,7 @@ bool BfMethodMatcher::CheckMethod(BfTypeInstance* targetTypeInstance, BfTypeInst
if (paramsArrayType->IsArray()) if (paramsArrayType->IsArray())
{ {
auto arrayType = (BfArrayType*)paramsArrayType; auto arrayType = (BfArrayType*)paramsArrayType;
paramsElementType = arrayType->mTypeGenericArguments[0]; paramsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
while (argIdx < (int)mArguments.size()) while (argIdx < (int)mArguments.size())
{ {
@ -5495,7 +5495,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
{ {
BfArrayType* arrayType = (BfArrayType*)wantType; BfArrayType* arrayType = (BfArrayType*)wantType;
mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods); mModule->PopulateType(arrayType, BfPopulateType_DataAndMethods);
expandedParamsElementType = arrayType->mTypeGenericArguments[0]; expandedParamsElementType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
int arrayClassSize = arrayType->mInstSize - expandedParamsElementType->mSize; int arrayClassSize = arrayType->mInstSize - expandedParamsElementType->mSize;
@ -5527,10 +5527,10 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, const BfTypedValu
{ {
int numElements = (int)argValues.size() - argIdx; int numElements = (int)argValues.size() - argIdx;
auto genericTypeInst = wantType->ToGenericTypeInstance(); auto genericTypeInst = wantType->ToGenericTypeInstance();
expandedParamsElementType = genericTypeInst->mTypeGenericArguments[0]; expandedParamsElementType = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0];
expandedParamsArray = BfTypedValue(mModule->CreateAlloca(wantType), wantType, true); 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(expandedParamAlloca, mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 1));
mModule->mBfIRBuilder->CreateStore(mModule->GetConstValue(numElements), mModule->mBfIRBuilder->CreateInBoundsGEP(expandedParamsArray.mValue, 0, 2)); 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") else if (memberName == "GenericParamCount")
{ {
auto genericTypeInst = type->ToGenericTypeInstance(); 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") else if (memberName == "Size")
_Int32Result(type->mSize); _Int32Result(type->mSize);
@ -11338,7 +11338,7 @@ void BfExprEvaluator::CheckObjectCreateTypeRef(BfType* expectingType, BfAstNode*
while (expectingType->IsArray()) while (expectingType->IsArray())
{ {
auto arrayType = (BfArrayType*)expectingType; auto arrayType = (BfArrayType*)expectingType;
expectingType = arrayType->mTypeGenericArguments[0]; expectingType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
} }
auto expectingTypeInst = expectingType->ToTypeInstance(); auto expectingTypeInst = expectingType->ToTypeInstance();
@ -14549,12 +14549,12 @@ BfTypedValue BfExprEvaluator::GetResult(bool clearResult, bool resolveGenericTyp
bool handled = false; bool handled = false;
if (mPropTarget.mType->IsGenericTypeInstance()) if (mPropTarget.mType->IsGenericTypeInstance())
{ {
auto genericTypeInst = (BfGenericTypeInstance*)mPropTarget.mType; auto genericTypeInst = (BfTypeInstance*)mPropTarget.mType;
if (genericTypeInst->mTypeDef == mModule->mCompiler->mSizedArrayTypeDef) if (genericTypeInst->mTypeDef == mModule->mCompiler->mSizedArrayTypeDef)
{ {
if (mPropDef->mName == "Count") if (mPropDef->mName == "Count")
{ {
auto sizedType = genericTypeInst->mTypeGenericArguments[1]; auto sizedType = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[1];
if (sizedType->IsConstExprValue()) if (sizedType->IsConstExprValue())
{ {
auto constExprType = (BfConstExprValueType*)sizedType; auto constExprType = (BfConstExprValueType*)sizedType;
@ -16371,7 +16371,7 @@ BfTypedValue BfExprEvaluator::SetupNullConditional(BfTypedValue thisValue, BfTok
if (thisValue.mType->IsNullable()) if (thisValue.mType->IsNullable())
{ {
BfGenericTypeInstance* nullableType = (BfGenericTypeInstance*)thisValue.mType->ToTypeInstance(); BfTypeInstance* nullableType = (BfTypeInstance*)thisValue.mType->ToTypeInstance();
auto elementType = nullableType->GetUnderlyingType(); auto elementType = nullableType->GetUnderlyingType();
if (elementType->IsValuelessType()) if (elementType->IsValuelessType())
{ {
@ -17126,8 +17126,8 @@ BfTypedValue BfExprEvaluator::PerformUnaryOperation_TryOperator(const BfTypedVal
// Check type generic constraints // Check type generic constraints
if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType())) if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType()))
{ {
auto genericTypeInst = (BfGenericTypeInstance*)mModule->mCurTypeInstance; auto genericTypeInst = (BfTypeInstance*)mModule->mCurTypeInstance;
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericParams.size(); genericParamIdx++) for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericTypeInfo->mGenericParams.size(); genericParamIdx++)
{ {
auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx); auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx);
for (auto& opConstraint : genericParam->mOperatorConstraints) for (auto& opConstraint : genericParam->mOperatorConstraints)
@ -18498,8 +18498,8 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod
// Check type generic constraints // Check type generic constraints
if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType())) if ((mModule->mCurTypeInstance->IsGenericTypeInstance()) && (mModule->mCurTypeInstance->IsUnspecializedType()))
{ {
auto genericTypeInst = (BfGenericTypeInstance*)mModule->mCurTypeInstance; auto genericTypeInst = (BfTypeInstance*)mModule->mCurTypeInstance;
for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericParams.size(); genericParamIdx++) for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericTypeInfo->mGenericParams.size(); genericParamIdx++)
{ {
auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx); auto genericParam = mModule->GetGenericTypeParamInstance(genericParamIdx);
for (auto& opConstraint : genericParam->mOperatorConstraints) for (auto& opConstraint : genericParam->mOperatorConstraints)

2
IDEHelper/Compiler/BfIRBuilder.cpp
View file

@ -2245,7 +2245,7 @@ void BfIRBuilder::CreateTypeDeclaration(BfType* type, bool forceDbgDefine)
if (checkType->IsArray()) if (checkType->IsArray())
{ {
BfArrayType* arrayType = (BfArrayType*)checkType; BfArrayType* arrayType = (BfArrayType*)checkType;
checkType = arrayType->mTypeGenericArguments[0]; checkType = arrayType->mGenericTypeInfo->mTypeGenericArguments[0];
} }
BfTypeInstance* outerType = NULL; BfTypeInstance* outerType = NULL;
if (!checkType->IsBoxed()) if (!checkType->IsBoxed())

14
IDEHelper/Compiler/BfMangler.cpp
View file

@ -211,11 +211,11 @@ void BfGNUMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
} }
BF_ASSERT(checkType->IsGenericTypeInstance()); BF_ASSERT(checkType->IsGenericTypeInstance());
BfGenericTypeInstance* genericTypeInstance = (BfGenericTypeInstance*)checkType; BfTypeInstance* genericTypeInstance = (BfTypeInstance*)checkType;
for (int genericParamIdx = genericParamStart; genericParamIdx < (int) typeDef->mGenericParamDefs.size(); genericParamIdx++) 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); Mangle(mangleContext, name, genericParam);
} }
@ -1203,9 +1203,9 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
{ {
auto typeDef = newNameSub.mTypeInst->mTypeDef; auto typeDef = newNameSub.mTypeInst->mTypeDef;
BfGenericTypeInstance* genericTypeInst = NULL; BfTypeInstance* genericTypeInst = NULL;
if (newNameSub.mTypeInst->IsGenericTypeInstance()) if (newNameSub.mTypeInst->IsGenericTypeInstance())
genericTypeInst = (BfGenericTypeInstance*)newNameSub.mTypeInst; genericTypeInst = (BfTypeInstance*)newNameSub.mTypeInst;
int numOuterGenericParams = 0; int numOuterGenericParams = 0;
if ((!mangleContext.mIsSafeMangle) && (typeDef->mOuterType != NULL)) if ((!mangleContext.mIsSafeMangle) && (typeDef->mOuterType != NULL))
@ -1249,7 +1249,7 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
if (genericTypeInst != NULL) if (genericTypeInst != NULL)
{ {
AddGenericArgs(mangleContext, name, genericTypeInst->mTypeGenericArguments, numOuterGenericParams); AddGenericArgs(mangleContext, name, genericTypeInst->mGenericTypeInfo->mTypeGenericArguments, numOuterGenericParams);
name += '@'; name += '@';
} }
} }
@ -1276,10 +1276,10 @@ bool BfMSMangler::FindOrCreateNameSub(MangleContext& mangleContext, StringImpl&
void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfTypeInstance* typeInstance, bool isAlreadyStarted, bool isOuterType) void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfTypeInstance* typeInstance, bool isAlreadyStarted, bool isOuterType)
{ {
BfGenericTypeInstance* genericTypeInst = NULL; BfTypeInstance* genericTypeInst = NULL;
if (typeInstance->IsGenericTypeInstance()) if (typeInstance->IsGenericTypeInstance())
{ {
genericTypeInst = (BfGenericTypeInstance*)typeInstance; genericTypeInst = (BfTypeInstance*)typeInstance;
} }
auto typeDef = typeInstance->mTypeDef; auto typeDef = typeInstance->mTypeDef;

47
IDEHelper/Compiler/BfModule.cpp
View file

@ -2969,8 +2969,8 @@ bool BfModule::CheckDefineMemberProtection(BfProtection protection, BfType* memb
if (memberTypeInstance->IsGenericTypeInstance()) if (memberTypeInstance->IsGenericTypeInstance())
{ {
// When we're a generic struct, our data layout can depend on our generic parameters as well // When we're a generic struct, our data layout can depend on our generic parameters as well
auto genericTypeInstance = (BfGenericTypeInstance*) memberTypeInstance; auto genericTypeInstance = (BfTypeInstance*) memberTypeInstance;
for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments) for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
{ {
if (!CheckDefineMemberProtection(protection, typeGenericArg)) if (!CheckDefineMemberProtection(protection, typeGenericArg))
return false; return false;
@ -3011,7 +3011,7 @@ void BfModule::AddDependency(BfType* usedType, BfType* userType, BfDependencyMap
usedType = usedType->GetUnderlyingType(); usedType = usedType->GetUnderlyingType();
else if (usedType->IsArray()) else if (usedType->IsArray())
{ {
usedType = ((BfGenericTypeInstance*)usedType)->mTypeGenericArguments[0]; usedType = ((BfTypeInstance*)usedType)->mGenericTypeInfo->mTypeGenericArguments[0];
} }
else else
break; break;
@ -3105,8 +3105,8 @@ void BfModule::AddDependency(BfType* usedType, BfType* userType, BfDependencyMap
return; return;
if (checkDType->IsGenericTypeInstance()) if (checkDType->IsGenericTypeInstance())
{ {
auto genericTypeInstance = (BfGenericTypeInstance*) checkDType; auto genericTypeInstance = (BfTypeInstance*) checkDType;
for (auto genericArg : genericTypeInstance->mTypeGenericArguments) for (auto genericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
{ {
AddDependency(genericArg, userType, BfDependencyMap::DependencyFlag_GenericArgRef); AddDependency(genericArg, userType, BfDependencyMap::DependencyFlag_GenericArgRef);
} }
@ -6147,7 +6147,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
SizedArray<BfIRValue, 4> unspecializedData = SizedArray<BfIRValue, 4> unspecializedData =
{ {
typeInstanceData, typeInstanceData,
GetConstValue((int)genericTypeInstance->mTypeGenericArguments.size(), byteType), // mGenericParamCount GetConstValue((int)genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments.size(), byteType), // mGenericParamCount
}; };
auto reflectUnspecializedGenericType = ResolveTypeDef(mCompiler->mReflectUnspecializedGenericType); auto reflectUnspecializedGenericType = ResolveTypeDef(mCompiler->mReflectUnspecializedGenericType);
typeInstanceDataType = mBfIRBuilder->MapTypeInst(reflectUnspecializedGenericType->ToTypeInstance(), BfIRPopulateType_Full); 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); auto unspecializedType = ResolveTypeDef(typeInstance->mTypeDef);
SizedArray<BfIRValue, 4> resolvedTypes; SizedArray<BfIRValue, 4> resolvedTypes;
for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments) for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
resolvedTypes.push_back(GetConstValue(typeGenericArg->mTypeId, typeIdType)); resolvedTypes.push_back(GetConstValue(typeGenericArg->mTypeId, typeIdType));
auto typeIRType = mBfIRBuilder->MapType(typeIdType); auto typeIRType = mBfIRBuilder->MapType(typeIdType);
@ -6185,7 +6185,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
{ {
auto arrayType = (BfArrayType*)typeInstance; auto arrayType = (BfArrayType*)typeInstance;
BfType* elementType = genericTypeInstance->mTypeGenericArguments[0]; BfType* elementType = genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[0];
BfFieldInstance* elementFieldInstance = &genericTypeInstance->mFieldInstances[0]; BfFieldInstance* elementFieldInstance = &genericTypeInstance->mFieldInstances[0];
SizedArray<BfIRValue, 4> arrayData = SizedArray<BfIRValue, 4> arrayData =
@ -6911,12 +6911,12 @@ bool BfModule::CheckGenericConstraints(const BfGenericParamSource& genericParamS
auto sizedArrayType = (BfSizedArrayType*)origCheckArgType; auto sizedArrayType = (BfSizedArrayType*)origCheckArgType;
if (convCheckConstraint->IsGenericTypeInstance()) if (convCheckConstraint->IsGenericTypeInstance())
{ {
auto convCheckConstraintInst = (BfGenericTypeInstance*)convCheckConstraint; auto convCheckConstraintInst = (BfTypeInstance*)convCheckConstraint;
if (convCheckConstraintInst->mTypeDef == mCompiler->mSizedArrayTypeDef) 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) if (sizedArrayType->mElementCount == constExprValueType->mValue.mInt64)
constraintMatched = true; constraintMatched = true;
} }
@ -9023,12 +9023,15 @@ BfMethodInstance* BfModule::GetUnspecializedMethodInstance(BfMethodInstance* met
{ {
if ((methodInstance->mMethodInfoEx != NULL) && (methodInstance->mMethodInfoEx->mMethodGenericArguments.size() != 0)) if ((methodInstance->mMethodInfoEx != NULL) && (methodInstance->mMethodInfoEx->mMethodGenericArguments.size() != 0))
methodInstance = methodInstance->mMethodInstanceGroup->mDefault; methodInstance = methodInstance->mMethodInstanceGroup->mDefault;
auto owner = methodInstance->mMethodInstanceGroup->mOwner; auto owner = methodInstance->mMethodInstanceGroup->mOwner;
if (!owner->IsGenericTypeInstance()) if (!owner->IsGenericTypeInstance())
return methodInstance; return methodInstance;
auto genericType = (BfGenericTypeInstance*)owner; BF_ASSERT(!owner->IsDelegateFromTypeRef());
BF_ASSERT(!owner->IsTuple());
auto genericType = (BfTypeInstance*)owner;
if (genericType->IsUnspecializedType()) if (genericType->IsUnspecializedType())
return methodInstance; return methodInstance;
@ -11540,10 +11543,10 @@ BfModuleMethodInstance BfModule::GetMethodInstance(BfTypeInstance* typeInst, BfM
isExternalExtensionMethod = true; isExternalExtensionMethod = true;
if (typeInst->IsGenericTypeInstance()) if (typeInst->IsGenericTypeInstance())
{ {
auto genericTypeInst = (BfGenericTypeInstance*)typeInst; auto genericTypeInst = (BfTypeInstance*)typeInst;
if (genericTypeInst->mProjectsReferenced.empty()) if (genericTypeInst->mGenericTypeInfo->mProjectsReferenced.empty())
genericTypeInst->GenerateProjectsReferenced(); 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 // This is a generic type where a generic param is already confined to the project in question
isExternalExtensionMethod = false; isExternalExtensionMethod = false;
@ -11563,11 +11566,11 @@ BfModuleMethodInstance BfModule::GetMethodInstance(BfTypeInstance* typeInst, BfM
int typeProjectsCounts = 0; int typeProjectsCounts = 0;
if (typeInst->IsGenericTypeInstance()) if (typeInst->IsGenericTypeInstance())
{ {
auto genericTypeInst = (BfGenericTypeInstance*)typeInst; auto genericTypeInst = (BfTypeInstance*)typeInst;
if (genericTypeInst->mProjectsReferenced.empty()) if (genericTypeInst->mGenericTypeInfo->mProjectsReferenced.empty())
genericTypeInst->GenerateProjectsReferenced(); genericTypeInst->GenerateProjectsReferenced();
typeProjectsCounts = (int)genericTypeInst->mProjectsReferenced.size(); typeProjectsCounts = (int)genericTypeInst->mGenericTypeInfo->mProjectsReferenced.size();
projectList.Insert(0, &genericTypeInst->mProjectsReferenced[0], genericTypeInst->mProjectsReferenced.size()); projectList.Insert(0, &genericTypeInst->mGenericTypeInfo->mProjectsReferenced[0], genericTypeInst->mGenericTypeInfo->mProjectsReferenced.size());
} }
else else
{ {
@ -15235,7 +15238,7 @@ void BfModule::EmitIteratorBlock(bool& skipBody)
if ((retTypeInst->mTypeDef == mCompiler->mGenericIEnumerableTypeDef) || if ((retTypeInst->mTypeDef == mCompiler->mGenericIEnumerableTypeDef) ||
(retTypeInst->mTypeDef == mCompiler->mGenericIEnumeratorTypeDef)) (retTypeInst->mTypeDef == mCompiler->mGenericIEnumeratorTypeDef))
{ {
innerRetType = retTypeInst->mTypeGenericArguments[0]; innerRetType = retTypeInst->mGenericTypeInfo->mTypeGenericArguments[0];
} }
} }

6
IDEHelper/Compiler/BfModule.h
View file

@ -1575,9 +1575,9 @@ public:
virtual void Visit(BfInlineAsmStatement* asmStmt) override; virtual void Visit(BfInlineAsmStatement* asmStmt) override;
// Type helpers // Type helpers
BfGenericExtensionEntry* BuildGenericExtensionInfo(BfGenericTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef); BfGenericExtensionEntry* BuildGenericExtensionInfo(BfTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef);
bool BuildGenericParams(BfType* resolvedTypeRef); 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 AreConstraintsSubset(BfGenericParamInstance* checkInner, BfGenericParamInstance* checkOuter);
bool CheckConstraintState(BfAstNode* refNode); bool CheckConstraintState(BfAstNode* refNode);
bool ShouldAllowMultipleDefinitions(BfTypeInstance* typeInst, BfTypeDef* firstDeclaringTypeDef, BfTypeDef* secondDeclaringTypeDef); bool ShouldAllowMultipleDefinitions(BfTypeInstance* typeInst, BfTypeDef* firstDeclaringTypeDef, BfTypeDef* secondDeclaringTypeDef);
@ -1614,7 +1614,7 @@ public:
bool IsThreadLocal(BfFieldInstance* fieldInstance); bool IsThreadLocal(BfFieldInstance* fieldInstance);
BfType* ResolveVarFieldType(BfTypeInstance* typeInst, BfFieldInstance* fieldInstance, BfFieldDef* field); BfType* ResolveVarFieldType(BfTypeInstance* typeInst, BfFieldInstance* fieldInstance, BfFieldDef* field);
void FindSubTypes(BfTypeInstance* classType, SizedArrayImpl<int>* outVals, SizedArrayImpl<BfTypeInstance*>* exChecks, bool isInterfacePass); 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); BfTypeInstance* GetUnspecializedTypeInstance(BfTypeInstance* typeInst);
BfArrayType* CreateArrayType(BfType* resolvedType, int dimensions); BfArrayType* CreateArrayType(BfType* resolvedType, int dimensions);
BfSizedArrayType* CreateSizedArrayType(BfType* resolvedType, int size); BfSizedArrayType* CreateSizedArrayType(BfType* resolvedType, int size);

448
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

File diff suppressed because it is too large Load diff

179
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -579,8 +579,8 @@ bool Beefy::BfMethodInstance::IsSpecializedGenericMethodOrType()
auto owner = GetOwner(); auto owner = GetOwner();
if (!owner->IsGenericTypeInstance()) if (!owner->IsGenericTypeInstance())
return false; return false;
BfGenericTypeInstance* genericTypeInstance = (BfGenericTypeInstance*)owner; BfTypeInstance* genericTypeInstance = (BfTypeInstance*)owner;
return !genericTypeInstance->mIsUnspecialized; return !genericTypeInstance->mGenericTypeInfo->mIsUnspecialized;
} }
bool BfMethodInstance::IsSpecializedByAutoCompleteMethod() bool BfMethodInstance::IsSpecializedByAutoCompleteMethod()
@ -1190,6 +1190,7 @@ BfMethodInstanceGroup::~BfMethodInstanceGroup()
BfTypeInstance::~BfTypeInstance() BfTypeInstance::~BfTypeInstance()
{ {
delete mTypeInfoEx; delete mTypeInfoEx;
delete mGenericTypeInfo;
delete mCustomAttributes; delete mCustomAttributes;
delete mAttributeData; delete mAttributeData;
for (auto methodInst : mInternalMethods) for (auto methodInst : mInternalMethods)
@ -1494,6 +1495,9 @@ bool BfTypeInstance::GetResultInfo(BfType*& valueType, int& okTagId)
void BfTypeInstance::ReportMemory(MemReporter* memReporter) void BfTypeInstance::ReportMemory(MemReporter* memReporter)
{ {
if (mGenericTypeInfo != NULL)
mGenericTypeInfo->ReportMemory(memReporter);
memReporter->Add(sizeof(BfTypeInstance)); memReporter->Add(sizeof(BfTypeInstance));
int depSize = 0; int depSize = 0;
@ -1589,7 +1593,7 @@ BfGenericExtensionEntry::~BfGenericExtensionEntry()
/// ///
BfGenericTypeInstance::~BfGenericTypeInstance() BfGenericTypeInfo::~BfGenericTypeInfo()
{ {
for (auto genericParamInstance : mGenericParams) for (auto genericParamInstance : mGenericParams)
genericParamInstance->Release(); genericParamInstance->Release();
@ -1597,33 +1601,39 @@ BfGenericTypeInstance::~BfGenericTypeInstance()
delete mGenericExtensionInfo; delete mGenericExtensionInfo;
} }
BfGenericTypeInstance::GenericParamsVector* BfGenericTypeInstance::GetGenericParamsVector(BfTypeDef* declaringTypeDef) BfGenericTypeInfo::GenericParamsVector* BfTypeInstance::GetGenericParamsVector(BfTypeDef* declaringTypeDef)
{ {
if (mGenericTypeInfo == NULL)
return NULL;
if ((declaringTypeDef == mTypeDef) || if ((declaringTypeDef == mTypeDef) ||
(declaringTypeDef->mTypeDeclaration == mTypeDef->mTypeDeclaration)) (declaringTypeDef->mTypeDeclaration == mTypeDef->mTypeDeclaration))
return &mGenericParams; return &mGenericTypeInfo->mGenericParams;
if (mGenericExtensionInfo == NULL) if (mGenericTypeInfo->mGenericExtensionInfo == NULL)
return NULL; return NULL;
BfGenericExtensionEntry* genericExEntry = NULL; BfGenericExtensionEntry* genericExEntry = NULL;
if (mGenericExtensionInfo->mExtensionMap.TryGetValue(declaringTypeDef, &genericExEntry)) if (mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(declaringTypeDef, &genericExEntry))
return &genericExEntry->mGenericParams; return &genericExEntry->mGenericParams;
return &mGenericParams; return &mGenericTypeInfo->mGenericParams;
} }
void BfGenericTypeInstance::GenerateProjectsReferenced() void BfTypeInstance::GenerateProjectsReferenced()
{ {
BF_ASSERT(mProjectsReferenced.empty()); if (mGenericTypeInfo == NULL)
mProjectsReferenced.push_back(mTypeDef->mProject); return;
for (auto genericArgType : mTypeGenericArguments) BF_ASSERT(mGenericTypeInfo->mProjectsReferenced.empty());
BfTypeUtils::GetProjectList(genericArgType, &mProjectsReferenced, 0); 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 we are specialized by an autocompleted method reference
if (methodArg->IsMethodRef()) if (methodArg->IsMethodRef())
@ -1637,14 +1647,16 @@ bool BfGenericTypeInstance::IsSpecializedByAutoCompleteMethod()
return false; return false;
} }
bool BfGenericTypeInstance::IsNullable() bool BfTypeInstance::IsNullable()
{ {
return (mTypeDef == mContext->mCompiler->mNullableTypeDef); 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) if (genericParam->mGenericParamFlags & BfGenericParamFlag_Var)
return true; return true;
@ -1652,9 +1664,11 @@ bool BfGenericTypeInstance::HasVarConstraints()
return false; 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; return true;
if ((typeDef == NULL) || (typeDef == activeTypeDef)) if ((typeDef == NULL) || (typeDef == activeTypeDef))
return true; return true;
@ -1666,10 +1680,10 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
return true; return true;
BfGenericExtensionEntry* genericExEntry = NULL; BfGenericExtensionEntry* genericExEntry = NULL;
if (!mGenericExtensionInfo->mExtensionMap.TryGetValue(typeDef, &genericExEntry)) if (!mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(typeDef, &genericExEntry))
return true; return true;
if (mIsUnspecialized) if (mGenericTypeInfo->mIsUnspecialized)
{ {
if (module == NULL) if (module == NULL)
return true; // During population return true; // During population
@ -1678,7 +1692,7 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
for (int genericIdx = 0; genericIdx < (int)declConstraints->size(); genericIdx++) for (int genericIdx = 0; genericIdx < (int)declConstraints->size(); genericIdx++)
{ {
auto genericType = mTypeGenericArguments[genericIdx]; auto genericType = mGenericTypeInfo->mTypeGenericArguments[genericIdx];
auto declGenericParam = (*declConstraints)[genericIdx]; auto declGenericParam = (*declConstraints)[genericIdx];
if (!module->CheckGenericConstraints(BfGenericParamSource(), genericType, NULL, declGenericParam)) if (!module->CheckGenericConstraints(BfGenericParamSource(), genericType, NULL, declGenericParam))
@ -1719,10 +1733,9 @@ bool BfGenericTypeInstance::IsTypeMemberIncluded(BfTypeDef* typeDef, BfTypeDef*
return genericExEntry->mConstraintsPassed; return genericExEntry->mConstraintsPassed;
} }
void BfGenericTypeInstance::ReportMemory(MemReporter* memReporter) void BfGenericTypeInfo::ReportMemory(MemReporter* memReporter)
{ {
BfTypeInstance::ReportMemory(memReporter); memReporter->Add(sizeof(BfGenericTypeInfo));
memReporter->Add(sizeof(BfGenericTypeInstance) - sizeof(BfTypeInstance));
memReporter->AddVec(mTypeGenericArgumentRefs, false); memReporter->AddVec(mTypeGenericArgumentRefs, false);
memReporter->AddVec(mTypeGenericArguments, false); memReporter->AddVec(mTypeGenericArguments, false);
memReporter->AddVec(mGenericParams, false); memReporter->AddVec(mGenericParams, false);
@ -1732,7 +1745,11 @@ void BfGenericTypeInstance::ReportMemory(MemReporter* memReporter)
BfType* BfTypeInstance::GetUnderlyingType() BfType* BfTypeInstance::GetUnderlyingType()
{ {
if (!mIsTypedPrimitive) if (!mIsTypedPrimitive)
{
if (mGenericTypeInfo != NULL)
return mGenericTypeInfo->mTypeGenericArguments[0];
return NULL; return NULL;
}
if (mTypeInfoEx == NULL) if (mTypeInfoEx == NULL)
mTypeInfoEx = new BfTypeInfoEx(); 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() BfType* BfBoxedType::GetModifiedElementType()
{ {
if ((mBoxedFlags & BoxedFlags_StructPtr) != 0) if ((mBoxedFlags & BoxedFlags_StructPtr) != 0)
@ -2210,7 +2171,7 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
else if (type->IsArray()) else if (type->IsArray())
{ {
BfArrayType* arrayType = (BfArrayType*)type; 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; return (elemHash << 5) - elemHash;
} }
else if (type->IsDelegateFromTypeRef() || type->IsFunctionFromTypeRef()) else if (type->IsDelegateFromTypeRef() || type->IsFunctionFromTypeRef())
@ -2281,8 +2242,8 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
} }
else if (type->IsGenericTypeInstance()) else if (type->IsGenericTypeInstance())
{ {
BfGenericTypeInstance* genericType = (BfGenericTypeInstance*)type; BfTypeInstance* genericType = (BfTypeInstance*)type;
for (auto genericArg : genericType->mTypeGenericArguments) for (auto genericArg : genericType->mGenericTypeInfo->mTypeGenericArguments)
hashVal = ((hashVal ^ (Hash(genericArg, ctx))) << 5) - hashVal; hashVal = ((hashVal ^ (Hash(genericArg, ctx))) << 5) - hashVal;
} }
return hashVal; return hashVal;
@ -2428,11 +2389,11 @@ int BfResolvedTypeSet::Hash(BfTypeReference* typeRef, LookupContext* ctx, BfHash
} }
BF_ASSERT(checkTypeInstance->IsGenericTypeInstance()); BF_ASSERT(checkTypeInstance->IsGenericTypeInstance());
auto curGenericTypeInst = (BfGenericTypeInstance*)checkTypeInstance; auto curGenericTypeInst = (BfTypeInstance*)checkTypeInstance;
int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size(); int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size();
for (int i = 0; i < numParentGenericParams; i++) 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); BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType);
if (commonOuterType != NULL) if (commonOuterType != NULL)
{ {
auto parentTypeInstance = (BfGenericTypeInstance*)ctx->mModule->mCurTypeInstance; auto parentTypeInstance = (BfTypeInstance*)ctx->mModule->mCurTypeInstance;
int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size(); int numParentGenericParams = (int)commonOuterType->mGenericParamDefs.size();
for (int i = 0; i < numParentGenericParams; i++) 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; BfArrayType* rhsArrayType = (BfArrayType*) rhs;
if (lhsArrayType->mDimensions != rhsArrayType->mDimensions) if (lhsArrayType->mDimensions != rhsArrayType->mDimensions)
return false; 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()) else if (lhs->IsTypeInstance())
{ {
@ -2925,15 +2886,15 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfType* rhs, LookupContext* ctx)
{ {
if (!rhs->IsGenericTypeInstance()) if (!rhs->IsGenericTypeInstance())
return false; return false;
BfGenericTypeInstance* lhsGenericType = (BfGenericTypeInstance*)lhs; BfTypeInstance* lhsGenericType = (BfTypeInstance*)lhs;
BfGenericTypeInstance* rhsGenericType = (BfGenericTypeInstance*)rhs; BfTypeInstance* rhsGenericType = (BfTypeInstance*)rhs;
if (lhsGenericType->mTypeGenericArguments.size() != rhsGenericType->mTypeGenericArguments.size()) if (lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size() != rhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size())
return false; return false;
if (lhsGenericType->mTypeDef != rhsGenericType->mTypeDef) if (lhsGenericType->mTypeDef != rhsGenericType->mTypeDef)
return false; 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; return false;
} }
} }
@ -3027,7 +2988,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfType* rhs, LookupContext* ctx)
return 0; 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"); //BP_ZONE("BfResolvedTypeSet::GenericTypeEquals");
@ -3059,7 +3020,7 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
return true; 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); auto rhsGenericTypeInstRef = BfNodeDynCastExact<BfGenericInstanceTypeRef>(rhs);
if (rhsGenericTypeInstRef == NULL) if (rhsGenericTypeInstRef == NULL)
@ -3072,7 +3033,7 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
return false; return false;
auto rhsElemType = ctx->mModule->ResolveTypeRef(rhsNullableTypeRef->mElementType, BfPopulateType_Identity, ctx->mResolveFlags); 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(); checkTypeInstance = checkTypeInstance->GetUnderlyingType()->ToTypeInstance();
BF_ASSERT(checkTypeInstance->IsGenericTypeInstance()); BF_ASSERT(checkTypeInstance->IsGenericTypeInstance());
int numParentGenericParams = (int) commonOuterType->mGenericParamDefs.size(); int numParentGenericParams = (int) commonOuterType->mGenericParamDefs.size();
auto curTypeInstance = (BfGenericTypeInstance*)checkTypeInstance; auto curTypeInstance = (BfTypeInstance*)checkTypeInstance;
if (lhsGenericType->mTypeGenericArguments.size() != numParentGenericParams) if (lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size() != numParentGenericParams)
return false; return false;
for (int i = 0; i < (int) numParentGenericParams; i++) for (int i = 0; i < (int) numParentGenericParams; i++)
if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mTypeGenericArguments[i]) if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i])
return false; return false;
return true; return true;
} }
@ -3120,12 +3081,12 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType); BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType);
if (commonOuterType != NULL) if (commonOuterType != NULL)
{ {
auto parentTypeInstance = (BfGenericTypeInstance*)ctx->mModule->mCurTypeInstance; auto parentTypeInstance = (BfTypeInstance*)ctx->mModule->mCurTypeInstance;
genericParamOffset = (int) commonOuterType->mGenericParamDefs.size(); genericParamOffset = (int) commonOuterType->mGenericParamDefs.size();
for (int i = 0; i < genericParamOffset; i++) 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; 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)) if ((ctx->mRootTypeRef != rhs) || (ctx->mRootTypeDef == NULL))
{ {
@ -3235,7 +3196,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
BfArrayType* lhsArrayType = (BfArrayType*) lhs; BfArrayType* lhsArrayType = (BfArrayType*) lhs;
if (lhsArrayType->mDimensions != rhsArrayTypeRef->mDimensions) if (lhsArrayType->mDimensions != rhsArrayTypeRef->mDimensions)
return false; 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()) else if (lhs->IsDelegateFromTypeRef() || lhs->IsFunctionFromTypeRef())
{ {
@ -3319,8 +3280,8 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
if (rhsType != NULL) if (rhsType != NULL)
return lhs == rhsType; return lhs == rhsType;
BfGenericTypeInstance* lhsGenericType = (BfGenericTypeInstance*) lhs; BfTypeInstance* lhsGenericType = (BfTypeInstance*) lhs;
return GenericTypeEquals(lhsGenericType, &lhsGenericType->mTypeGenericArguments, rhs, rhsTypeDef, ctx); return GenericTypeEquals(lhsGenericType, &lhsGenericType->mGenericTypeInfo->mTypeGenericArguments, rhs, rhsTypeDef, ctx);
} }
else else
{ {

220
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -375,7 +375,7 @@ public:
class BfDependedType; class BfDependedType;
class BfTypeInstance; class BfTypeInstance;
class BfGenericTypeInstance; class BfTypeInstance;
class BfPrimitiveType; class BfPrimitiveType;
enum BfTypeRebuildFlags enum BfTypeRebuildFlags
@ -466,7 +466,7 @@ public:
virtual BfDependedType* ToDependedType() { return NULL; } virtual BfDependedType* ToDependedType() { return NULL; }
virtual BfTypeInstance* ToTypeInstance() { return NULL; } virtual BfTypeInstance* ToTypeInstance() { return NULL; }
virtual BfGenericTypeInstance* ToGenericTypeInstance() { return NULL; } virtual BfTypeInstance* ToGenericTypeInstance() { return NULL; }
virtual BfPrimitiveType* ToPrimitiveType() { return NULL; } virtual BfPrimitiveType* ToPrimitiveType() { return NULL; }
virtual bool IsDependendType() { return false; } virtual bool IsDependendType() { return false; }
virtual bool IsTypeInstance() { 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 // Instance of struct or class
class BfTypeInstance : public BfDependedType class BfTypeInstance : public BfDependedType
{ {
@ -1625,6 +1685,7 @@ public:
BfCustomAttributes* mCustomAttributes; BfCustomAttributes* mCustomAttributes;
BfAttributeData* mAttributeData; BfAttributeData* mAttributeData;
BfTypeInfoEx* mTypeInfoEx; BfTypeInfoEx* mTypeInfoEx;
BfGenericTypeInfo* mGenericTypeInfo;
Array<BfTypeInterfaceEntry> mInterfaces; Array<BfTypeInterfaceEntry> mInterfaces;
Array<BfTypeInterfaceMethodEntry> mInterfaceMethodTable; Array<BfTypeInterfaceMethodEntry> mInterfaceMethodTable;
@ -1690,6 +1751,7 @@ public:
mCustomAttributes = NULL; mCustomAttributes = NULL;
mAttributeData = NULL; mAttributeData = NULL;
mTypeInfoEx = NULL; mTypeInfoEx = NULL;
mGenericTypeInfo = NULL;
//mClassVData = NULL; //mClassVData = NULL;
mVirtualMethodTableSize = 0; mVirtualMethodTableSize = 0;
mHotTypeData = NULL; mHotTypeData = NULL;
@ -1767,6 +1829,18 @@ public:
virtual bool WantsGCMarking() override; virtual bool WantsGCMarking() override;
virtual BfTypeCode GetLoweredType() 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 BfTypeInstance* GetImplBaseType() { return mBaseType; }
virtual bool IsIRFuncUsed(BfIRFunction func); virtual bool IsIRFuncUsed(BfIRFunction func);
@ -1786,6 +1860,8 @@ public:
int GetInstStride() { return BF_ALIGN(mInstSize, mInstAlign); } int GetInstStride() { return BF_ALIGN(mInstSize, mInstAlign); }
bool HasOverrideMethods(); bool HasOverrideMethods();
bool GetResultInfo(BfType*& valueType, int& okTagId); bool GetResultInfo(BfType*& valueType, int& okTagId);
BfGenericTypeInfo::GenericParamsVector* GetGenericParamsVector(BfTypeDef* declaringTypeDef);
void GenerateProjectsReferenced();
virtual void ReportMemory(MemReporter* memReporter) override; virtual void ReportMemory(MemReporter* memReporter) override;
}; };
@ -1856,7 +1932,7 @@ public:
virtual bool IsDependentOnUnderlyingType() override { return true; } virtual bool IsDependentOnUnderlyingType() override { return true; }
virtual BfType* GetUnderlyingType() override { return mElementType; } 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 IsSpecializedType() override { return !mElementType->IsUnspecializedType(); }
virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); } virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); }
virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedTypeVariation(); } virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedTypeVariation(); }
@ -1871,79 +1947,6 @@ public:
BfType* GetModifiedElementType(); 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 class BfTypeAliasType : public BfTypeInstance
{ {
public: public:
@ -1957,22 +1960,6 @@ public:
virtual bool IsTypeAlias() override { return true; } virtual bool IsTypeAlias() override { return true; }
virtual BfType* GetUnderlyingType() override { return mAliasToType; } 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(); } virtual bool WantsGCMarking() override { return mAliasToType->WantsGCMarking(); }
}; };
@ -2036,28 +2023,6 @@ public:
virtual BfDelegateInfo* GetDelegateInfo() { return &mDelegateInfo; } 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 class BfTupleType : public BfTypeInstance
{ {
public: public:
@ -2082,25 +2047,6 @@ public:
virtual bool IsUnspecializedTypeVariation() override { return mIsUnspecializedTypeVariation; } 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 class BfConcreteInterfaceType : public BfType
{ {
public: public:
@ -2213,7 +2159,7 @@ public:
virtual bool IsValuelessType() override { return mElementType->IsValuelessType(); } virtual bool IsValuelessType() override { return mElementType->IsValuelessType(); }
}; };
class BfArrayType : public BfGenericTypeInstance class BfArrayType : public BfTypeInstance
{ {
public: public:
int mDimensions; int mDimensions;
@ -2391,8 +2337,8 @@ public:
public: public:
static BfVariant EvaluateToVariant(LookupContext* ctx, BfExpression* expr, BfType*& constGenericParam); 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(BfTypeInstance* 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* typeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx);
static void HashGenericArguments(BfTypeReference* typeRef, LookupContext* ctx, int& hash); static void HashGenericArguments(BfTypeReference* typeRef, LookupContext* ctx, int& hash);
static int Hash(BfType* type, LookupContext* ctx, bool allowRef = false); static int Hash(BfType* type, LookupContext* ctx, bool allowRef = false);
static int DirectHash(BfTypeReference* typeRef, LookupContext* ctx, BfHashFlags flags = BfHashFlag_None); static int DirectHash(BfTypeReference* typeRef, LookupContext* ctx, BfHashFlags flags = BfHashFlag_None);
@ -2483,7 +2429,7 @@ public:
auto genericTypeInst = typeInst->ToGenericTypeInstance(); auto genericTypeInst = typeInst->ToGenericTypeInstance();
if (genericTypeInst != NULL) if (genericTypeInst != NULL)
{ {
for (auto genericArg : genericTypeInst->mTypeGenericArguments) for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
GetProjectList(genericArg, projectList, immutableLength); GetProjectList(genericArg, projectList, immutableLength);
} }

12
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

@ -5845,10 +5845,10 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
if (genericParamInst->mTypeConstraint->IsGenericTypeInstance()) if (genericParamInst->mTypeConstraint->IsGenericTypeInstance())
{ {
auto genericConstraintType = (BfGenericTypeInstance*)genericParamInst->mTypeConstraint; auto genericConstraintType = (BfTypeInstance*)genericParamInst->mTypeConstraint;
if (genericConstraintType->mTypeDef == mCompiler->mSizedArrayTypeDef) if (genericConstraintType->mTypeDef == mCompiler->mSizedArrayTypeDef)
{ {
varType = genericConstraintType->mTypeGenericArguments[0]; varType = genericConstraintType->mGenericTypeInfo->mTypeGenericArguments[0];
isVarEnumerator = true; isVarEnumerator = true;
} }
} }
@ -5909,7 +5909,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
{ {
PopulateType(itr.mType, BfPopulateType_DataAndMethods); PopulateType(itr.mType, BfPopulateType_DataAndMethods);
BfGenericTypeInstance* genericItrInterface = NULL; BfTypeInstance* genericItrInterface = NULL;
auto _CheckInterface = [&](BfTypeInstance* interface) auto _CheckInterface = [&](BfTypeInstance* interface)
{ {
@ -5924,7 +5924,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
genericItrInterface = itrInterface->ToGenericTypeInstance(); genericItrInterface = itrInterface->ToGenericTypeInstance();
if (inferVarType) if (inferVarType)
{ {
varType = genericItrInterface->mTypeGenericArguments[0]; varType = genericItrInterface->mGenericTypeInfo->mTypeGenericArguments[0];
if (isRefExpression) if (isRefExpression)
{ {
if (varType->IsPointer()) if (varType->IsPointer())
@ -5950,7 +5950,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
genericItrInterface = itrInterface->ToGenericTypeInstance(); genericItrInterface = itrInterface->ToGenericTypeInstance();
if (inferVarType) if (inferVarType)
{ {
varType = genericItrInterface->mTypeGenericArguments[0]; varType = genericItrInterface->mGenericTypeInfo->mTypeGenericArguments[0];
if (isRefExpression) if (isRefExpression)
{ {
if (varType->IsPointer()) if (varType->IsPointer())
@ -6093,7 +6093,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
if (nextResult.mType->IsGenericTypeInstance()) if (nextResult.mType->IsGenericTypeInstance())
{ {
nextEmbeddedType = ((BfGenericTypeInstance*)nextResult.mType)->mTypeGenericArguments[0]; nextEmbeddedType = ((BfTypeInstance*)nextResult.mType)->mGenericTypeInfo->mTypeGenericArguments[0];
} }
} }
if (nextEmbeddedType == NULL) if (nextEmbeddedType == NULL)

4
IDEHelper/DbgExprEvaluator.cpp
View file

@ -86,8 +86,8 @@ DwMethodMatcher::DwMethodMatcher(BfAstNode* targetSrc, DbgExprEvaluator* exprEva
{ {
if (!argType->IsGenericTypeInstance()) if (!argType->IsGenericTypeInstance())
return true; return true;
auto wantGenericType = (BfGenericTypeInstance*)wantType; auto wantGenericType = (BfTypeInstance*)wantType;
auto argGenericType = (BfGenericTypeInstance*)argType; auto argGenericType = (BfTypeInstance*)argType;
if (argGenericType->mTypeDef != wantGenericType->mTypeDef) if (argGenericType->mTypeDef != wantGenericType->mTypeDef)
return true; return true;

7
IDEHelper/Tests/src/Aliases.bf
View file

@ -19,6 +19,9 @@ namespace Tests
public typealias AliasA5 = (int, T); public typealias AliasA5 = (int, T);
public typealias AliasA6<T2> = (T, T2); public typealias AliasA6<T2> = (T, T2);
public typealias AliasA7 = T[];
public typealias AliasA8 = T[3];
public delegate T Zag(); public delegate T Zag();
} }
@ -31,6 +34,10 @@ namespace Tests
ClassA<T>.AliasA6<float> t0 = (default(T), 1.2f); ClassA<T>.AliasA6<float> t0 = (default(T), 1.2f);
ClassA<T>.AliasA4<int16> dlg0 = scope => LocalA; 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] [Test]