From 9f00539d900982a88342bde9f706fb2002275e3b Mon Sep 17 00:00:00 2001 From: Brian Fiete Date: Fri, 5 Jun 2020 07:01:58 -0700 Subject: [PATCH] Refactored generic type instances to be a BfGenericTypeInfo member --- IDEHelper/Compiler/BfAutoComplete.cpp | 4 +- IDEHelper/Compiler/BfCompiler.cpp | 28 +- IDEHelper/Compiler/BfConstResolver.cpp | 2 +- IDEHelper/Compiler/BfContext.cpp | 31 +- IDEHelper/Compiler/BfContext.h | 8 +- IDEHelper/Compiler/BfExprEvaluator.cpp | 70 ++-- IDEHelper/Compiler/BfIRBuilder.cpp | 2 +- IDEHelper/Compiler/BfMangler.cpp | 14 +- IDEHelper/Compiler/BfModule.cpp | 47 ++- IDEHelper/Compiler/BfModule.h | 6 +- IDEHelper/Compiler/BfModuleTypeUtils.cpp | 448 +++++++++++---------- IDEHelper/Compiler/BfResolvedTypeUtils.cpp | 179 ++++---- IDEHelper/Compiler/BfResolvedTypeUtils.h | 220 ++++------ IDEHelper/Compiler/BfStmtEvaluator.cpp | 12 +- IDEHelper/DbgExprEvaluator.cpp | 4 +- IDEHelper/Tests/src/Aliases.bf | 7 + 16 files changed, 504 insertions(+), 578 deletions(-) diff --git a/IDEHelper/Compiler/BfAutoComplete.cpp b/IDEHelper/Compiler/BfAutoComplete.cpp index 708ca99b..c5cd98c1 100644 --- a/IDEHelper/Compiler/BfAutoComplete.cpp +++ b/IDEHelper/Compiler/BfAutoComplete.cpp @@ -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); } } } diff --git a/IDEHelper/Compiler/BfCompiler.cpp b/IDEHelper/Compiler/BfCompiler.cpp index 6ca0f5f5..efe5e42e 100644 --- a/IDEHelper/Compiler/BfCompiler.cpp +++ b/IDEHelper/Compiler/BfCompiler.cpp @@ -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) @@ -4977,7 +4977,7 @@ void BfCompiler::PopulateReified() // Check reifications forced by virtuals or interfaces if ((!mIsResolveOnly) && (typeInst != NULL) && (typeInst->mIsReified) && (typeInst->IsObject()) && (!typeInst->IsUnspecializedType()) && (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 (typeInst->mTypeDef->mIsCombinedPartial) { @@ -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"; } } diff --git a/IDEHelper/Compiler/BfConstResolver.cpp b/IDEHelper/Compiler/BfConstResolver.cpp index 4753e722..26e1bdab 100644 --- a/IDEHelper/Compiler/BfConstResolver.cpp +++ b/IDEHelper/Compiler/BfConstResolver.cpp @@ -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; } } diff --git a/IDEHelper/Compiler/BfContext.cpp b/IDEHelper/Compiler/BfContext.cpp index 5076e203..433d29c8 100644 --- a/IDEHelper/Compiler/BfContext.cpp +++ b/IDEHelper/Compiler/BfContext.cpp @@ -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); } } diff --git a/IDEHelper/Compiler/BfContext.h b/IDEHelper/Compiler/BfContext.h index 9ac05539..308fe0bb 100644 --- a/IDEHelper/Compiler/BfContext.h +++ b/IDEHelper/Compiler/BfContext.h @@ -371,11 +371,10 @@ public: BfAllocPool mUnknownSizedArrayTypePool; BfAllocPool mBoxedTypePool; BfAllocPool mTupleTypePool; - BfAllocPool mGenericTupleTypePool; + BfAllocPool mAliasTypePool; BfAllocPool mRefTypePool; BfAllocPool mRetTypeTypePool; - BfAllocPool mGenericTypeInstancePool; - BfAllocPool mGenericTypeAliasPool; + BfAllocPool mGenericTypeInstancePool; BfAllocPool mArrayTypeInstancePool; BfAllocPool mGenericParamTypePool; BfAllocPool mTypeDefTypeRefPool; @@ -383,8 +382,7 @@ public: BfAllocPool mGenericTypeRefPool; BfAllocPool mConcreteInterfaceTypePool; BfAllocPool mConstExprValueTypePool; - BfAllocPool mDelegateTypePool; - BfAllocPool mGenericDelegateTypePool; + BfAllocPool mDelegateTypePool; BfPrimitiveType* mPrimitiveTypes[BfTypeCode_Length]; BfPrimitiveType* mPrimitiveStructTypes[BfTypeCode_Length]; diff --git a/IDEHelper/Compiler/BfExprEvaluator.cpp b/IDEHelper/Compiler/BfExprEvaluator.cpp index 6680fa96..35184574 100644 --- a/IDEHelper/Compiler/BfExprEvaluator.cpp +++ b/IDEHelper/Compiler/BfExprEvaluator.cpp @@ -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) diff --git a/IDEHelper/Compiler/BfIRBuilder.cpp b/IDEHelper/Compiler/BfIRBuilder.cpp index 65f9bc9e..b0de022a 100644 --- a/IDEHelper/Compiler/BfIRBuilder.cpp +++ b/IDEHelper/Compiler/BfIRBuilder.cpp @@ -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()) diff --git a/IDEHelper/Compiler/BfMangler.cpp b/IDEHelper/Compiler/BfMangler.cpp index 3d1db843..9b78c802 100644 --- a/IDEHelper/Compiler/BfMangler.cpp +++ b/IDEHelper/Compiler/BfMangler.cpp @@ -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; diff --git a/IDEHelper/Compiler/BfModule.cpp b/IDEHelper/Compiler/BfModule.cpp index 8fe434e7..55c9ceb0 100644 --- a/IDEHelper/Compiler/BfModule.cpp +++ b/IDEHelper/Compiler/BfModule.cpp @@ -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& usedStrin SizedArray 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& usedStrin auto unspecializedType = ResolveTypeDef(typeInstance->mTypeDef); SizedArray 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& usedStrin { auto arrayType = (BfArrayType*)typeInstance; - BfType* elementType = genericTypeInstance->mTypeGenericArguments[0]; + BfType* elementType = genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[0]; BfFieldInstance* elementFieldInstance = &genericTypeInstance->mFieldInstances[0]; SizedArray 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; } @@ -9023,12 +9023,15 @@ BfMethodInstance* BfModule::GetUnspecializedMethodInstance(BfMethodInstance* met { if ((methodInstance->mMethodInfoEx != NULL) && (methodInstance->mMethodInfoEx->mMethodGenericArguments.size() != 0)) methodInstance = methodInstance->mMethodInstanceGroup->mDefault; - + auto owner = methodInstance->mMethodInstanceGroup->mOwner; 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]; } } diff --git a/IDEHelper/Compiler/BfModule.h b/IDEHelper/Compiler/BfModule.h index d93279b0..6985f0ce 100644 --- a/IDEHelper/Compiler/BfModule.h +++ b/IDEHelper/Compiler/BfModule.h @@ -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* outVals, SizedArrayImpl* 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); diff --git a/IDEHelper/Compiler/BfModuleTypeUtils.cpp b/IDEHelper/Compiler/BfModuleTypeUtils.cpp index b6f09b08..b1399d8e 100644 --- a/IDEHelper/Compiler/BfModuleTypeUtils.cpp +++ b/IDEHelper/Compiler/BfModuleTypeUtils.cpp @@ -38,22 +38,22 @@ int32 GetNumLowZeroBits(int32 n) USING_NS_BF; -BfGenericExtensionEntry* BfModule::BuildGenericExtensionInfo(BfGenericTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef) +BfGenericExtensionEntry* BfModule::BuildGenericExtensionInfo(BfTypeInstance* genericTypeInst, BfTypeDef* partialTypeDef) { if (!partialTypeDef->IsExtension()) return NULL; - if (partialTypeDef->mGenericParamDefs.size() != genericTypeInst->mTypeGenericArguments.size()) + if (partialTypeDef->mGenericParamDefs.size() != genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size()) { AssertErrorState(); return NULL; } - BfGenericExtensionInfo* genericExtensionInfo = genericTypeInst->mGenericExtensionInfo; + BfGenericExtensionInfo* genericExtensionInfo = genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo; if (genericExtensionInfo == NULL) { genericExtensionInfo = new BfGenericExtensionInfo(); - genericTypeInst->mGenericExtensionInfo = genericExtensionInfo; + genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo = genericExtensionInfo; } BfTypeState typeState; @@ -66,7 +66,7 @@ BfGenericExtensionEntry* BfModule::BuildGenericExtensionInfo(BfGenericTypeInstan genericExtensionInfo->mExtensionMap.TryAdd(partialTypeDef, NULL, &genericExEntry); int startDefGenericParamIdx = (int)genericExEntry->mGenericParams.size(); - for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mTypeGenericArguments.size(); paramIdx++) + for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); paramIdx++) { auto genericParamInstance = new BfGenericTypeParamInstance(partialTypeDef, paramIdx); genericParamInstance->mExternType = GetGenericParamType(BfGenericParamKind_Type, paramIdx); @@ -75,11 +75,11 @@ BfGenericExtensionEntry* BfModule::BuildGenericExtensionInfo(BfGenericTypeInstan genericExEntry->mGenericParams.push_back(genericParamInstance); } - for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mTypeGenericArguments.size(); paramIdx++) + for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); paramIdx++) { auto genericParamInstance = genericExEntry->mGenericParams[paramIdx]; - auto rootGenericParamInstance = genericTypeInst->mGenericParams[paramIdx]; + auto rootGenericParamInstance = genericTypeInst->mGenericTypeInfo->mGenericParams[paramIdx]; genericParamInstance->mTypeConstraint = rootGenericParamInstance->mTypeConstraint; genericParamInstance->mInterfaceConstraints = rootGenericParamInstance->mInterfaceConstraints; genericParamInstance->mGenericParamFlags |= rootGenericParamInstance->mGenericParamFlags; @@ -110,18 +110,18 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) auto genericTypeInst = resolvedTypeRef->ToGenericTypeInstance(); - if (genericTypeInst->mTypeGenericArguments[0]->IsGenericParam()) + if (genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[0]->IsGenericParam()) { - BF_ASSERT(genericTypeInst->mIsUnspecialized); + BF_ASSERT(genericTypeInst->mGenericTypeInfo->mIsUnspecialized); } auto typeDef = genericTypeInst->mTypeDef; - int startDefGenericParamIdx = (int)genericTypeInst->mGenericParams.size(); - for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mTypeGenericArguments.size(); paramIdx++) + int startDefGenericParamIdx = (int)genericTypeInst->mGenericTypeInfo->mGenericParams.size(); + for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); paramIdx++) { auto genericParamInstance = new BfGenericTypeParamInstance(typeDef, paramIdx); genericParamInstance->mExternType = GetGenericParamType(BfGenericParamKind_Type, paramIdx); - genericTypeInst->mGenericParams.push_back(genericParamInstance); + genericTypeInst->mGenericTypeInfo->mGenericParams.push_back(genericParamInstance); } if (!typeDef->mPartials.empty()) @@ -131,10 +131,10 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) if (!partialTypeDef->IsExtension()) { typeState.mCurTypeDef = partialTypeDef; - for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mTypeGenericArguments.size(); paramIdx++) + for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); paramIdx++) { auto genericParamDef = typeDef->mGenericParamDefs[paramIdx]; - auto genericParamInstance = genericTypeInst->mGenericParams[paramIdx]; + auto genericParamInstance = genericTypeInst->mGenericTypeInfo->mGenericParams[paramIdx]; ResolveGenericParamConstraints(genericParamInstance, genericTypeInst->IsUnspecializedType()); for (auto nameNode : genericParamDef->mNameNodes) @@ -158,7 +158,7 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) genericParamSource.mCheckAccessibility = false; genericParamSource.mTypeInstance = genericTypeInst; BfError* error = NULL; - if (!CheckGenericConstraints(genericParamSource, genericTypeInst->mTypeGenericArguments[paramIdx], NULL, genericParamInstance, NULL, &error)) + if (!CheckGenericConstraints(genericParamSource, genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[paramIdx], NULL, genericParamInstance, NULL, &error)) { genericExEntry->mConstraintsPassed = false; } @@ -169,9 +169,9 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) } else { - for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericParams.size(); paramIdx++) + for (int paramIdx = startDefGenericParamIdx; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mGenericParams.size(); paramIdx++) { - auto genericParamInstance = genericTypeInst->mGenericParams[paramIdx]; + auto genericParamInstance = genericTypeInst->mGenericTypeInfo->mGenericParams[paramIdx]; ResolveGenericParamConstraints(genericParamInstance, genericTypeInst->IsUnspecializedType()); auto genericParamDef = genericParamInstance->GetGenericParamDef(); if (genericParamDef != NULL) @@ -184,7 +184,7 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) } } - for (auto genericParam : genericTypeInst->mGenericParams) + for (auto genericParam : genericTypeInst->mGenericTypeInfo->mGenericParams) { for (auto constraintTypeInst : genericParam->mInterfaceConstraints) AddDependency(constraintTypeInst, mCurTypeInstance, BfDependencyMap::DependencyFlag_Constraint); @@ -195,7 +195,7 @@ bool BfModule::BuildGenericParams(BfType* resolvedTypeRef) return true; } -bool BfModule::ValidateGenericConstraints(BfTypeReference* typeRef, BfGenericTypeInstance* genericTypeInst, bool ignoreErrors) +bool BfModule::ValidateGenericConstraints(BfTypeReference* typeRef, BfTypeInstance* genericTypeInst, bool ignoreErrors) { if ((mCurTypeInstance != NULL) && (mCurTypeInstance->IsTypeAlias())) { @@ -205,27 +205,27 @@ bool BfModule::ValidateGenericConstraints(BfTypeReference* typeRef, BfGenericTyp } SetAndRestoreValue prevIgnoreErrors(mIgnoreErrors, mIgnoreErrors || ignoreErrors); - genericTypeInst->mValidatedGenericConstraints = true; + genericTypeInst->mGenericTypeInfo->mValidatedGenericConstraints = true; if (genericTypeInst->IsTypeAlias()) { auto underlyingType = genericTypeInst->GetUnderlyingType(); if ((underlyingType != NULL) && (underlyingType->IsGenericTypeInstance())) - return ValidateGenericConstraints(typeRef, (BfGenericTypeInstance*)underlyingType, ignoreErrors); + return ValidateGenericConstraints(typeRef, (BfTypeInstance*)underlyingType, ignoreErrors); return true; } auto typeDef = genericTypeInst->mTypeDef; - for (int paramIdx = 0; paramIdx < (int)genericTypeInst->mTypeGenericArguments.size(); paramIdx++) + for (int paramIdx = 0; paramIdx < (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); paramIdx++) { - auto genericParamInstance = genericTypeInst->mGenericParams[paramIdx]; + auto genericParamInstance = genericTypeInst->mGenericTypeInfo->mGenericParams[paramIdx]; // Why did we remove this line? This breaks determining compatibility of one unspecialized type to another unspecialized type, called from ResolveTypeResult //if (!genericTypeInst->mIsUnspecialized) { BfError* error = NULL; - if (!CheckGenericConstraints(BfGenericParamSource(genericTypeInst), genericTypeInst->mTypeGenericArguments[paramIdx], typeRef, genericParamInstance, NULL, &error)) + if (!CheckGenericConstraints(BfGenericParamSource(genericTypeInst), genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[paramIdx], typeRef, genericParamInstance, NULL, &error)) { - genericTypeInst->mHadValidateErrors = true; + genericTypeInst->mGenericTypeInfo->mHadValidateErrors = true; return false; } } @@ -317,8 +317,8 @@ bool BfModule::ShouldAllowMultipleDefinitions(BfTypeInstance* typeInst, BfTypeDe { bool alwaysCoincide = true; - auto genericTypeInst = (BfGenericTypeInstance*)typeInst; - if (genericTypeInst->mGenericExtensionInfo != NULL) + auto genericTypeInst = (BfTypeInstance*)typeInst; + if (genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo != NULL) { auto firstConstraints = genericTypeInst->GetGenericParamsVector(firstDeclaringTypeDef); auto secondConstraints = genericTypeInst->GetGenericParamsVector(secondDeclaringTypeDef); @@ -420,12 +420,12 @@ bool BfModule::InitType(BfType* resolvedTypeRef, BfPopulateType populateType) if (resolvedTypeRef->IsGenericTypeInstance()) { - auto genericTypeInst = (BfGenericTypeInstance*)resolvedTypeRef; + auto genericTypeInst = (BfTypeInstance*)resolvedTypeRef; //BF_ASSERT(genericTypeInst->mGenericParams.size() <= genericTypeInst->mTypeGenericArguments.size()); // BF_ASSERT((genericTypeInst->mGenericParams.size() == 0) || // (genericTypeInst->mGenericParams.size() == genericTypeInst->mTypeGenericArguments.size())); - for (auto typeGenericArg : genericTypeInst->mTypeGenericArguments) + for (auto typeGenericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments) BF_ASSERT((typeGenericArg->mRebuildFlags & BfTypeRebuildFlag_Deleted) == 0); } @@ -467,10 +467,10 @@ bool BfModule::InitType(BfType* resolvedTypeRef, BfPopulateType populateType) resolvedTypeRef->mContext = mContext; if (resolvedTypeRef->IsGenericTypeInstance()) { - auto genericTypeInstance = (BfGenericTypeInstance*)resolvedTypeRef; + auto genericTypeInstance = (BfTypeInstance*)resolvedTypeRef; #ifdef _DEBUG - for (auto genericArg : genericTypeInstance->mTypeGenericArguments) + for (auto genericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments) BF_ASSERT(!genericArg->IsVar()); #endif @@ -512,8 +512,8 @@ void BfModule::AddFieldDependency(BfTypeInstance* typeInstance, BfFieldInstance* if ((fieldTypeInstance->IsStruct()) && (fieldTypeInstance->IsGenericTypeInstance())) { // When we're a generic struct, our data layout can depend on our generic parameters as well - auto genericTypeInstance = (BfGenericTypeInstance*)fieldTypeInstance; - for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments) + auto genericTypeInstance = (BfTypeInstance*)fieldTypeInstance; + for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments) AddFieldDependency(typeInstance, fieldInstance, typeGenericArg); } } @@ -881,6 +881,11 @@ bool BfModule::PopulateType(BfType* resolvedTypeRef, BfPopulateType populateType else resolvedTypeRef->mTypeId = mCompiler->mCurTypeId++; + if (resolvedTypeRef->IsTuple()) + { + NOP; + } + while (resolvedTypeRef->mTypeId >= (int)mContext->mTypes.size()) mContext->mTypes.Add(NULL); mContext->mTypes[resolvedTypeRef->mTypeId] = resolvedTypeRef; @@ -944,11 +949,8 @@ bool BfModule::PopulateType(BfType* resolvedTypeRef, BfPopulateType populateType if (typeAlias->mTypeFailed) aliasToType = NULL; - - if (resolvedTypeRef->IsGenericTypeInstance()) - ((BfGenericTypeAliasType*)resolvedTypeRef)->mAliasToType = aliasToType; - else - ((BfTypeAliasType*)resolvedTypeRef)->mAliasToType = aliasToType; + + ((BfTypeAliasType*)resolvedTypeRef)->mAliasToType = aliasToType; if (aliasToType != NULL) { @@ -1394,7 +1396,7 @@ int BfModule::GenerateTypeOptions(BfCustomAttributes* customAttributes, BfTypeIn if ((!typeInstance->IsBoxed()) && (typeInstance->mTypeDef == mCompiler->mPointerTTypeDef)) { BF_ASSERT(typeInstance->IsGenericTypeInstance()); - auto innerType = ((BfGenericTypeInstance*)typeInstance)->mTypeGenericArguments[0]; + auto innerType = typeInstance->mGenericTypeInfo->mTypeGenericArguments[0]; auto ptrType = CreatePointerType(innerType); String typeName = TypeToString(ptrType); _CheckTypeName(typeName); @@ -1548,8 +1550,8 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy if (typeInstance->IsGenericTypeInstance()) { - auto genericTypeInst = (BfGenericTypeInstance*)typeInstance; - if (genericTypeInst->mGenericParams.size() == 0) + auto genericTypeInst = (BfTypeInstance*)typeInstance; + if (genericTypeInst->mGenericTypeInfo->mGenericParams.size() == 0) BuildGenericParams(resolvedTypeRef); } @@ -1727,10 +1729,10 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy if (typeInstance->IsGenericTypeInstance()) { - auto genericTypeInstance = (BfGenericTypeInstance*)typeInstance; + auto genericTypeInstance = (BfTypeInstance*)typeInstance; // Add generic dependencies if needed - for (auto genericType : genericTypeInstance->mTypeGenericArguments) + for (auto genericType : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments) { if (genericType->IsPrimitiveType()) genericType = GetWrappedStructType(genericType); @@ -1872,7 +1874,7 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy struct _DeferredValidate { BfTypeReference* mTypeRef; - BfGenericTypeInstance* mGenericType; + BfTypeInstance* mGenericType; }; Array<_DeferredValidate> deferredTypeValidateList; @@ -2068,7 +2070,7 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy if (auto genericTypeInst = typeInstance->ToGenericTypeInstance()) { - if ((genericTypeInst->IsSpecializedType()) && (!genericTypeInst->mValidatedGenericConstraints) && (!typeInstance->IsBoxed())) + if ((genericTypeInst->IsSpecializedType()) && (!genericTypeInst->mGenericTypeInfo->mValidatedGenericConstraints) && (!typeInstance->IsBoxed())) { SetAndRestoreValue ignoreErrors(mIgnoreErrors, true); ValidateGenericConstraints(NULL, genericTypeInst, false); @@ -3651,7 +3653,7 @@ void BfModule::DoTypeInstanceMethodProcessing(BfTypeInstance* typeInstance) bool isFailedType = mCurTypeInstance->mTypeFailed; if (auto genericTypeInst = mCurTypeInstance->ToGenericTypeInstance()) { - if (genericTypeInst->mHadValidateErrors) + if (genericTypeInst->mGenericTypeInfo->mHadValidateErrors) isFailedType = true; } @@ -4512,11 +4514,13 @@ BfArrayType* BfModule::CreateArrayType(BfType* resolvedType, int dimensions) BF_ASSERT(!resolvedType->IsVar()); auto arrayType = mContext->mArrayTypePool.Get(); + delete arrayType->mGenericTypeInfo; + arrayType->mGenericTypeInfo = new BfGenericTypeInfo(); arrayType->mContext = mContext; arrayType->mTypeDef = mCompiler->GetArrayTypeDef(dimensions); arrayType->mDimensions = dimensions; - arrayType->mTypeGenericArguments.clear(); - arrayType->mTypeGenericArguments.push_back(resolvedType); + arrayType->mGenericTypeInfo->mTypeGenericArguments.clear(); + arrayType->mGenericTypeInfo->mTypeGenericArguments.push_back(resolvedType); auto resolvedArrayType = ResolveType(arrayType); if (resolvedArrayType != arrayType) mContext->mArrayTypePool.GiveBack(arrayType); @@ -5078,8 +5082,11 @@ BfTypeInstance* BfModule::CreateTupleType(const BfTypeVector& fieldTypes, const } auto resolvedTupleType = ResolveType(tupleType); - if (resolvedTupleType != tupleType) + if (resolvedTupleType != tupleType) + { + BF_ASSERT(tupleType->mContext != NULL); mContext->mTupleTypePool.GiveBack((BfTupleType*)tupleType); + } return (BfTupleType*)resolvedTupleType; } @@ -5343,8 +5350,8 @@ BfType* BfModule::ResolveInnerType(BfType* outerType, BfTypeReference* typeRef, BfTypeVector genericArgs; if (outerType->IsGenericTypeInstance()) { - auto genericTypeInst = (BfGenericTypeInstance*)outerType; - genericArgs = genericTypeInst->mTypeGenericArguments; + auto genericTypeInst = (BfTypeInstance*)outerType; + genericArgs = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments; } if (genericTypeRef != NULL) @@ -5423,8 +5430,8 @@ BfTypeInstance* BfModule::GetOuterType(BfType* type) BfTypeVector typeGenericArguments; if (type->IsGenericTypeInstance()) { - auto genericType = (BfGenericTypeInstance*)type; - typeGenericArguments = genericType->mTypeGenericArguments; + auto genericType = (BfTypeInstance*)type; + typeGenericArguments = genericType->mGenericTypeInfo->mTypeGenericArguments; } BF_ASSERT((intptr)typeGenericArguments.size() >= (intptr)outerTypeDef->mGenericParamDefs.size()); typeGenericArguments.resize(outerTypeDef->mGenericParamDefs.size()); @@ -5479,13 +5486,15 @@ BfType* BfModule::ResolveTypeDef(BfTypeDef* typeDef, const BfTypeVector& generic arrayInstType->mDimensions = 2; auto typeRef = mContext->mTypeDefTypeRefPool.Get(); typeRef->mTypeDef = typeDef; + delete arrayInstType->mGenericTypeInfo; + arrayInstType->mGenericTypeInfo = new BfGenericTypeInfo(); arrayInstType->mTypeDef = typeDef; - arrayInstType->mIsUnspecialized = false; - arrayInstType->mTypeGenericArguments.clear(); + arrayInstType->mGenericTypeInfo->mIsUnspecialized = false; + arrayInstType->mGenericTypeInfo->mTypeGenericArguments.clear(); for (auto genericArg : genericArgs) { - arrayInstType->mIsUnspecialized |= genericArg->IsGenericParam(); - arrayInstType->mTypeGenericArguments.push_back(genericArg); + arrayInstType->mGenericTypeInfo->mIsUnspecialized |= genericArg->IsGenericParam(); + arrayInstType->mGenericTypeInfo->mTypeGenericArguments.push_back(genericArg); } if (genericArgs.size() == 0) @@ -5493,14 +5502,16 @@ BfType* BfModule::ResolveTypeDef(BfTypeDef* typeDef, const BfTypeVector& generic for (int i = 0; i < (int)typeDef->mGenericParamDefs.size(); i++) { auto genericParamTypeRef = GetGenericParamType(BfGenericParamKind_Type, i); - arrayInstType->mTypeGenericArguments.push_back(genericParamTypeRef); - arrayInstType->mIsUnspecialized = true; + arrayInstType->mGenericTypeInfo->mTypeGenericArguments.push_back(genericParamTypeRef); + arrayInstType->mGenericTypeInfo->mIsUnspecialized = true; } } auto resolvedType = ResolveType(arrayInstType, populateType); if (resolvedType != arrayInstType) { + delete arrayInstType->mGenericTypeInfo; + arrayInstType->mGenericTypeInfo = NULL; mContext->mArrayTypeInstancePool.GiveBack(arrayInstType); mContext->mTypeDefTypeRefPool.GiveBack(typeRef); } @@ -5508,25 +5519,28 @@ BfType* BfModule::ResolveTypeDef(BfTypeDef* typeDef, const BfTypeVector& generic return resolvedType; } - BfGenericTypeInstance* genericInstType; + BfTypeInstance* genericInstType; if (typeDef->mTypeCode == BfTypeCode_TypeAlias) - genericInstType = mContext->mGenericTypeAliasPool.Get(); + genericInstType = mContext->mAliasTypePool.Get(); else genericInstType = mContext->mGenericTypeInstancePool.Get(); - BF_ASSERT(genericInstType->mGenericParams.size() == 0); + delete genericInstType->mGenericTypeInfo; + genericInstType->mGenericTypeInfo = new BfGenericTypeInfo(); + + BF_ASSERT(genericInstType->mGenericTypeInfo->mGenericParams.size() == 0); BF_ASSERT((genericInstType->mRebuildFlags & BfTypeRebuildFlag_AddedToWorkList) == 0); genericInstType->mRebuildFlags = (BfTypeRebuildFlags)(genericInstType->mRebuildFlags & ~BfTypeRebuildFlag_InTempPool); genericInstType->mContext = mContext; auto typeRef = mContext->mTypeDefTypeRefPool.Get(); typeRef->mTypeDef = typeDef; genericInstType->mTypeDef = typeDef; - genericInstType->mIsUnspecialized = false; - genericInstType->mTypeGenericArguments.clear(); + genericInstType->mGenericTypeInfo->mIsUnspecialized = false; + genericInstType->mGenericTypeInfo->mTypeGenericArguments.clear(); genericInstType->mTypeFailed = false; for (auto genericArg : genericArgs) { - genericInstType->mIsUnspecialized |= genericArg->IsGenericParam(); - genericInstType->mTypeGenericArguments.push_back(genericArg); + genericInstType->mGenericTypeInfo->mIsUnspecialized |= genericArg->IsGenericParam(); + genericInstType->mGenericTypeInfo->mTypeGenericArguments.push_back(genericArg); } if (genericArgs.size() == 0) @@ -5534,8 +5548,8 @@ BfType* BfModule::ResolveTypeDef(BfTypeDef* typeDef, const BfTypeVector& generic for (int i = 0; i < (int)typeDef->mGenericParamDefs.size(); i++) { auto genericParamTypeRef = GetGenericParamType(BfGenericParamKind_Type, i); - genericInstType->mTypeGenericArguments.push_back(genericParamTypeRef); - genericInstType->mIsUnspecialized = true; + genericInstType->mGenericTypeInfo->mTypeGenericArguments.push_back(genericParamTypeRef); + genericInstType->mGenericTypeInfo->mIsUnspecialized = true; } } @@ -5567,12 +5581,13 @@ BfType* BfModule::ResolveTypeDef(BfTypeDef* typeDef, const BfTypeVector& generic if (resolvedType != genericInstType) { - BF_ASSERT(genericInstType->mGenericParams.size() == 0); + BF_ASSERT(genericInstType->mGenericTypeInfo->mGenericParams.size() == 0); BF_ASSERT((genericInstType->mRebuildFlags & BfTypeRebuildFlag_AddedToWorkList) == 0); genericInstType->mRebuildFlags = (BfTypeRebuildFlags)(genericInstType->mRebuildFlags | BfTypeRebuildFlag_InTempPool); - + delete genericInstType->mGenericTypeInfo; + genericInstType->mGenericTypeInfo = NULL; if (typeDef->mTypeCode == BfTypeCode_TypeAlias) - mContext->mGenericTypeAliasPool.GiveBack((BfGenericTypeAliasType*)genericInstType); + mContext->mAliasTypePool.GiveBack((BfTypeAliasType*)genericInstType); else mContext->mGenericTypeInstancePool.GiveBack(genericInstType); mContext->mTypeDefTypeRefPool.GiveBack(typeRef); @@ -5641,7 +5656,7 @@ BfTypeDef* BfModule::ResolveGenericInstanceDef(BfGenericInstanceTypeRef* generic String findName = typeRef->ToString(); if ((mCurTypeInstance != NULL) && (mCurTypeInstance->IsGenericTypeInstance())) { - auto genericTypeInst = (BfGenericTypeInstance*)mCurTypeInstance; + auto genericTypeInst = (BfTypeInstance*)mCurTypeInstance; for (int genericParamIdx = 0; genericParamIdx < (int)curTypeDef->mGenericParamDefs.size(); genericParamIdx++) { String genericName = curTypeDef->mGenericParamDefs[genericParamIdx]->mName; @@ -5817,9 +5832,9 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty if (wantGeneric) { Array genericArgs; - for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericTupleType->mTypeGenericArguments.size(); genericArgIdx++) + for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericTupleType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++) { - BfType* resolvedArg = unspecializedGenericTupleType->mTypeGenericArguments[genericArgIdx]; + BfType* resolvedArg = unspecializedGenericTupleType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx]; if (resolvedArg->IsUnspecializedType()) { resolvedArg = ResolveGenericType(resolvedArg, typeGenericArguments, methodGenericArguments, allowFail); @@ -5831,19 +5846,22 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty genericArgs.push_back(resolvedArg); } - auto actualTupleType = mContext->mGenericTupleTypePool.Get(); - actualTupleType->mIsUnspecialized = false; - actualTupleType->mIsUnspecializedVariation = false; - actualTupleType->mTypeGenericArguments = genericArgs; - for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericTupleType->mTypeGenericArguments.size(); genericArgIdx++) + auto actualTupleType = mContext->mTupleTypePool.Get(); + delete actualTupleType->mGenericTypeInfo; + actualTupleType->mGenericTypeInfo = new BfGenericTypeInfo(); + actualTupleType->mGenericTypeInfo->mIsUnspecialized = false; + actualTupleType->mGenericTypeInfo->mIsUnspecializedVariation = false; + actualTupleType->mGenericTypeInfo->mTypeGenericArguments = genericArgs; + for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericTupleType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++) { auto typeGenericArg = genericArgs[genericArgIdx]; if ((typeGenericArg->IsGenericParam()) || (typeGenericArg->IsUnspecializedType())) - actualTupleType->mIsUnspecialized = true; - actualTupleType->mGenericParams.push_back(unspecializedGenericTupleType->mGenericParams[genericArgIdx]->AddRef()); + actualTupleType->mGenericTypeInfo->mIsUnspecialized = true; + actualTupleType->mGenericTypeInfo->mGenericParams.push_back(unspecializedGenericTupleType->mGenericTypeInfo->mGenericParams[genericArgIdx]->AddRef()); } CheckUnspecializedGenericType(actualTupleType, BfPopulateType_Identity); - + actualTupleType->mIsUnspecializedType = actualTupleType->mGenericTypeInfo->mIsUnspecialized; + actualTupleType->mIsUnspecializedTypeVariation = actualTupleType->mGenericTypeInfo->mIsUnspecializedVariation; actualTupleType->Init(baseType->mTypeDef->mProject, baseType); for (int fieldIdx = 0; fieldIdx < (int)fieldTypes.size(); fieldIdx++) @@ -5871,6 +5889,7 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty tupleType = actualTupleType; } + tupleType->mContext = mContext; tupleType->mFieldInstances.Resize(fieldTypes.size()); for (int fieldIdx = 0; fieldIdx < (int)fieldTypes.size(); fieldIdx++) { @@ -5887,16 +5906,9 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty if (resolvedType != tupleType) { - if (tupleType->IsGenericTypeInstance()) - { - auto genericTupleType = (BfGenericTupleType*)tupleType; - for (auto genericParam : genericTupleType->mGenericParams) - genericParam->Release(); - genericTupleType->mGenericParams.Clear(); - mContext->mGenericTupleTypePool.GiveBack(genericTupleType); - } - else - mContext->mTupleTypePool.GiveBack((BfTupleType*)tupleType); + delete tupleType->mGenericTypeInfo; + tupleType->mGenericTypeInfo = NULL; + mContext->mTupleTypePool.GiveBack((BfTupleType*)tupleType); } BF_ASSERT((resolvedType == NULL) || resolvedType->IsTypeInstance() || resolvedType->IsPrimitiveType()); return resolvedType; @@ -5905,7 +5917,7 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty if ((unspecializedType->IsDelegateFromTypeRef()) || (unspecializedType->IsFunctionFromTypeRef())) { BfTypeInstance* unspecializedDelegateType = (BfTypeInstance*)unspecializedType; - BfGenericTypeInstance* unspecializedGenericDelegateType = unspecializedType->ToGenericTypeInstance(); + BfTypeInstance* unspecializedGenericDelegateType = unspecializedType->ToGenericTypeInstance(); BfDelegateInfo* unspecializedDelegateInfo = unspecializedType->GetDelegateInfo(); bool wantGeneric = false; @@ -5950,9 +5962,9 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty if (wantGeneric) { Array genericArgs; - for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericDelegateType->mTypeGenericArguments.size(); genericArgIdx++) + for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericDelegateType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++) { - BfType* resolvedArg = unspecializedGenericDelegateType->mTypeGenericArguments[genericArgIdx]; + BfType* resolvedArg = unspecializedGenericDelegateType->mGenericTypeInfo->mTypeGenericArguments[genericArgIdx]; if (resolvedArg->IsUnspecializedType()) { resolvedArg = ResolveGenericType(resolvedArg, typeGenericArguments, methodGenericArguments, allowFail); @@ -5964,18 +5976,22 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty genericArgs.push_back(resolvedArg); } - auto dlgType = mContext->mGenericDelegateTypePool.Get(); - dlgType->mIsUnspecialized = false; - dlgType->mIsUnspecializedVariation = false; - dlgType->mTypeGenericArguments = genericArgs; - for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericDelegateType->mTypeGenericArguments.size(); genericArgIdx++) + auto dlgType = mContext->mDelegateTypePool.Get(); + delete dlgType->mGenericTypeInfo; + dlgType->mGenericTypeInfo = new BfGenericTypeInfo(); + dlgType->mGenericTypeInfo->mIsUnspecialized = false; + dlgType->mGenericTypeInfo->mIsUnspecializedVariation = false; + dlgType->mGenericTypeInfo->mTypeGenericArguments = genericArgs; + for (int genericArgIdx = 0; genericArgIdx < (int)unspecializedGenericDelegateType->mGenericTypeInfo->mTypeGenericArguments.size(); genericArgIdx++) { auto typeGenericArg = genericArgs[genericArgIdx]; if ((typeGenericArg->IsGenericParam()) || (typeGenericArg->IsUnspecializedType())) - dlgType->mIsUnspecialized = true; - dlgType->mGenericParams.push_back(unspecializedGenericDelegateType->mGenericParams[genericArgIdx]->AddRef()); + dlgType->mGenericTypeInfo->mIsUnspecialized = true; + dlgType->mGenericTypeInfo->mGenericParams.push_back(unspecializedGenericDelegateType->mGenericTypeInfo->mGenericParams[genericArgIdx]->AddRef()); } CheckUnspecializedGenericType(dlgType, BfPopulateType_Identity); + dlgType->mIsUnspecializedType = dlgType->mGenericTypeInfo->mIsUnspecialized; + dlgType->mIsUnspecializedTypeVariation = dlgType->mGenericTypeInfo->mIsUnspecializedVariation; delegateType = dlgType; } else @@ -6069,17 +6085,10 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty AddDependency(paramType, delegateType, BfDependencyMap::DependencyFlag_ParamOrReturnValue); } else - { - if (delegateType->IsGenericTypeInstance()) - { - auto dlgType = (BfGenericDelegateType*)delegateType; - for (auto genericParam : dlgType->mGenericParams) - genericParam->Release(); - dlgType->mGenericParams.Clear(); - mContext->mGenericDelegateTypePool.GiveBack(dlgType); - } - else - mContext->mDelegateTypePool.GiveBack((BfDelegateType*)delegateType); + { + delete delegateType->mGenericTypeInfo; + delegateType->mGenericTypeInfo = NULL; + mContext->mDelegateTypePool.GiveBack((BfDelegateType*)delegateType); } BF_ASSERT((resolvedType == NULL) || resolvedType->IsTypeInstance() || resolvedType->IsPrimitiveType()); return resolvedType; @@ -6087,10 +6096,10 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty if (unspecializedType->IsGenericTypeInstance()) { - auto genericTypeInst = (BfGenericTypeInstance*)unspecializedType; + auto genericTypeInst = (BfTypeInstance*)unspecializedType; BfTypeVector genericArgs; - for (auto genericArg : genericTypeInst->mTypeGenericArguments) + for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments) { if (genericArg->IsUnspecializedType()) { @@ -6106,12 +6115,12 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty } auto resolvedType = ResolveTypeDef(genericTypeInst->mTypeDef, genericArgs, BfPopulateType_BaseType); - BfGenericTypeInstance* specializedType = NULL; + BfTypeInstance* specializedType = NULL; if (resolvedType != NULL) specializedType = resolvedType->ToGenericTypeInstance(); if (specializedType != NULL) { - if (specializedType->mHadValidateErrors) + if (specializedType->mGenericTypeInfo->mHadValidateErrors) return NULL; } @@ -6135,20 +6144,12 @@ BfType* BfModule::ResolveType(BfType* lookupType, BfPopulateType populateType) } if (lookupType->IsGenericTypeInstance()) - CheckUnspecializedGenericType((BfGenericTypeInstance*)lookupType, populateType); + CheckUnspecializedGenericType((BfTypeInstance*)lookupType, populateType); if (lookupType->IsTuple()) - { - if (lookupType->IsGenericTypeInstance()) - { - auto tupleType = (BfGenericTupleType*)lookupType; - tupleType->Finish(); - } - else - { - auto tupleType = (BfTupleType*)lookupType; - tupleType->Finish(); - } + { + auto tupleType = (BfTupleType*)lookupType; + tupleType->Finish(); } resolvedEntry->mValue = lookupType; @@ -6175,15 +6176,15 @@ BfGenericParamInstance* BfModule::GetGenericTypeParamInstance(int genericParamId if (mCurMethodInstance != NULL) curTypeInstance = mCurMethodInstance->mMethodInstanceGroup->mOwner; - BfGenericTypeInstance* genericTypeInst = curTypeInstance->ToGenericTypeInstance(); - if ((genericTypeInst->IsIncomplete()) && (genericTypeInst->mGenericParams.size() == 0)) + BfTypeInstance* genericTypeInst = curTypeInstance->ToGenericTypeInstance(); + if ((genericTypeInst->IsIncomplete()) && (genericTypeInst->mGenericTypeInfo->mGenericParams.size() == 0)) { // Set this to NULL so we don't recurse infinitely SetAndRestoreValue prevTypeInst(mCurTypeInstance, NULL); PopulateType(genericTypeInst, BfPopulateType_Declaration); } - if (genericTypeInst->mGenericExtensionInfo != NULL) + if (genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo != NULL) { auto activeTypeDef = GetActiveTypeDef(NULL, true); if ((activeTypeDef->mTypeDeclaration != genericTypeInst->mTypeDef->mTypeDeclaration) && (activeTypeDef->IsExtension())) @@ -6193,7 +6194,7 @@ BfGenericParamInstance* BfModule::GetGenericTypeParamInstance(int genericParamId lookupTypeDef = lookupTypeDef->mOuterType; BfGenericExtensionEntry* genericExEntry; - if (genericTypeInst->mGenericExtensionInfo->mExtensionMap.TryGetValue(lookupTypeDef, &genericExEntry)) + if (genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo->mExtensionMap.TryGetValue(lookupTypeDef, &genericExEntry)) { return genericExEntry->mGenericParams[genericParamIdx]; } @@ -6208,7 +6209,7 @@ BfGenericParamInstance* BfModule::GetGenericTypeParamInstance(int genericParamId } BF_ASSERT(genericTypeInst != NULL); - return genericTypeInst->mGenericParams[genericParamIdx]; + return genericTypeInst->mGenericTypeInfo->mGenericParams[genericParamIdx]; } BfGenericParamInstance* BfModule::GetGenericParamInstance(BfGenericParamType* type) @@ -6436,7 +6437,7 @@ BfType* BfModule::ResolveTypeResult(BfTypeReference* typeRef, BfType* resolvedTy } BfTypeInstance* typeInstance = resolvedTypeRef->ToTypeInstance(); - BfGenericTypeInstance* genericTypeInstance = resolvedTypeRef->ToGenericTypeInstance(); + BfTypeInstance* genericTypeInstance = resolvedTypeRef->ToGenericTypeInstance(); auto populateModule = this; if ((resolveFlags & BfResolveTypeRefFlag_NoReify) != 0) @@ -6447,7 +6448,9 @@ BfType* BfModule::ResolveTypeResult(BfTypeReference* typeRef, BfType* resolvedTy if ((genericTypeInstance != NULL) && (genericTypeInstance != mCurTypeInstance) && (populateType > BfPopulateType_Identity)) { - bool doValidate = (genericTypeInstance->mHadValidateErrors) || (!genericTypeInstance->mValidatedGenericConstraints) || (genericTypeInstance->mIsUnspecializedVariation); + bool doValidate = (genericTypeInstance->mGenericTypeInfo->mHadValidateErrors) || + (!genericTypeInstance->mGenericTypeInfo->mValidatedGenericConstraints) || + (genericTypeInstance->mGenericTypeInfo->mIsUnspecializedVariation); if ((mCurMethodInstance != NULL) && (mCurMethodInstance->mIsUnspecializedVariation)) doValidate = false; if (mCurTypeInstance != NULL) @@ -6456,7 +6459,7 @@ BfType* BfModule::ResolveTypeResult(BfTypeReference* typeRef, BfType* resolvedTy doValidate = false; if (auto curGenericTypeInstance = mCurTypeInstance->ToGenericTypeInstance()) { - if (curGenericTypeInstance->mHadValidateErrors) + if (curGenericTypeInstance->mGenericTypeInfo->mHadValidateErrors) doValidate = false; } if ((mContext->mCurTypeState != NULL) && (mContext->mCurTypeState->mCurBaseTypeRef != NULL)) // We validate constraints for base types later @@ -7003,10 +7006,10 @@ BfTypedValue BfModule::TryLookupGenericConstVaue(BfIdentifierNode* identifierNod bool disallowConstExprValue = false; if ((genericCheckTypeInstance != NULL) && (genericCheckTypeInstance->IsGenericTypeInstance())) { - auto genericTypeInst = (BfGenericTypeInstance*)genericCheckTypeInstance; + auto genericTypeInst = (BfTypeInstance*)genericCheckTypeInstance; auto* genericParams = &curTypeDef->mGenericParamDefs; - if (genericTypeInst->mGenericExtensionInfo != NULL) + if (genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo != NULL) { auto activeTypeDef = GetActiveTypeDef(NULL, true); genericParams = &activeTypeDef->mGenericParamDefs; @@ -7020,8 +7023,8 @@ BfTypedValue BfModule::TryLookupGenericConstVaue(BfIdentifierNode* identifierNod if (genericName == findName) { genericParamDef = checkGenericParamDef; - genericParamResult = genericTypeInst->mTypeGenericArguments[genericParamIdx]; - genericTypeConstraint = genericTypeInst->mGenericParams[genericParamIdx]->mTypeConstraint; + genericParamResult = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[genericParamIdx]; + genericTypeConstraint = genericTypeInst->mGenericTypeInfo->mGenericParams[genericParamIdx]->mTypeConstraint; HandleTypeGenericParamRef(identifierNode, genericTypeInst->mTypeDef, genericParamIdx); } @@ -7232,10 +7235,10 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula bool disallowConstExprValue = false; if ((genericCheckTypeInstance != NULL) && (genericCheckTypeInstance->IsGenericTypeInstance())) { - auto genericTypeInst = (BfGenericTypeInstance*)genericCheckTypeInstance; + auto genericTypeInst = (BfTypeInstance*)genericCheckTypeInstance; auto* genericParams = &curTypeDef->mGenericParamDefs; - if (genericTypeInst->mGenericExtensionInfo != NULL) + if (genericTypeInst->mGenericTypeInfo->mGenericExtensionInfo != NULL) { auto activeTypeDef = GetActiveTypeDef(NULL, true); genericParams = &activeTypeDef->mGenericParamDefs; @@ -7261,7 +7264,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula SetAndRestoreValue prevSymbolRefKind; if (mCompiler->mResolvePassData != NULL) // Don't add these typeRefs, they are indirect prevSymbolRefKind.Init(mCompiler->mResolvePassData->mGetSymbolReferenceKind, BfGetSymbolReferenceKind_None); - genericParamResult = genericTypeInst->mTypeGenericArguments[genericParamIdx]; + genericParamResult = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[genericParamIdx]; if ((genericParamResult != NULL) && (genericParamResult->IsConstExprValue()) && ((resolveFlags & BfResolveTypeRefFlag_AllowGenericTypeParamConstValue) == 0)) @@ -7788,21 +7791,22 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula return ResolveTypeResult(typeRef, NULL, populateType, resolveFlags); } - auto parentGenericTypeInstance = (BfGenericTypeInstance*)checkCurType; + auto parentGenericTypeInstance = (BfTypeInstance*)checkCurType; - BfGenericTypeInstance* genericTypeInst; + BfTypeInstance* genericTypeInst; if (typeDef->mTypeCode == BfTypeCode_TypeAlias) { - auto typeAliasType = new BfGenericTypeAliasType(); + auto typeAliasType = new BfTypeAliasType(); genericTypeInst = typeAliasType; } else - genericTypeInst = new BfGenericTypeInstance(); + genericTypeInst = new BfTypeInstance(); + genericTypeInst->mGenericTypeInfo = new BfGenericTypeInfo(); genericTypeInst->mTypeDef = typeDef; for (int i = 0; i < numParentGenericParams; i++) { - genericTypeInst->mGenericParams.push_back(parentGenericTypeInstance->mGenericParams[i]->AddRef()); - genericTypeInst->mTypeGenericArguments.push_back(parentGenericTypeInstance->mTypeGenericArguments[i]); + genericTypeInst->mGenericTypeInfo->mGenericParams.push_back(parentGenericTypeInstance->mGenericTypeInfo->mGenericParams[i]->AddRef()); + genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.push_back(parentGenericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i]); } CheckUnspecializedGenericType(genericTypeInst, populateType); @@ -7931,10 +7935,11 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula } BfArrayType* arrayType = new BfArrayType(); + arrayType->mGenericTypeInfo = new BfGenericTypeInfo(); arrayType->mContext = mContext; arrayType->mDimensions = arrayTypeRef->mDimensions; arrayType->mTypeDef = mCompiler->GetArrayTypeDef(arrayType->mDimensions); - arrayType->mTypeGenericArguments.push_back(elementType); + arrayType->mGenericTypeInfo->mTypeGenericArguments.push_back(elementType); resolvedEntry->mValue = arrayType; CheckUnspecializedGenericType(arrayType, populateType); @@ -7991,11 +7996,11 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula if ((commonOuterType) && (mCurTypeInstance->IsGenericTypeInstance())) { int startDefGenericParamIdx = (int)commonOuterType->mGenericParamDefs.size(); - auto parentTypeInstance = (BfGenericTypeInstance*)mCurTypeInstance; + auto parentTypeInstance = (BfTypeInstance*)mCurTypeInstance; if (parentTypeInstance->IsTypeAlias()) - parentTypeInstance = (BfGenericTypeInstance*)GetOuterType(parentTypeInstance)->ToTypeInstance(); + parentTypeInstance = (BfTypeInstance*)GetOuterType(parentTypeInstance)->ToTypeInstance(); for (int i = 0; i < startDefGenericParamIdx; i++) - genericArgs.push_back(parentTypeInstance->mTypeGenericArguments[i]); + genericArgs.push_back(parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i]); } } @@ -8010,7 +8015,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula genericArgs.Add(genericArg); } - BfGenericTypeInstance* genericTypeInst; + BfTypeInstance* genericTypeInst; if ((type != NULL) && ((type->IsDelegateFromTypeRef()) || (type->IsFunctionFromTypeRef()))) { @@ -8024,13 +8029,13 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula } else if ((typeDef != NULL) && (typeDef->mTypeCode == BfTypeCode_TypeAlias)) { - auto typeAliasType = new BfGenericTypeAliasType(); + auto typeAliasType = new BfTypeAliasType(); genericTypeInst = typeAliasType; } else - genericTypeInst = new BfGenericTypeInstance(); + genericTypeInst = new BfTypeInstance(); genericTypeInst->mContext = mContext; - + genericTypeInst->mGenericTypeInfo = new BfGenericTypeInfo(); BF_ASSERT(typeDef->mDefState != BfTypeDef::DefState_Deleted); @@ -8039,7 +8044,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula { // Is a generic type for sure... // We need this case for generic methods - genericParamCount = (int)((BfGenericTypeInstance*)type)->mTypeGenericArguments.size(); + genericParamCount = (int)((BfTypeInstance*)type)->mGenericTypeInfo->mTypeGenericArguments.size(); } else if (typeDef->mGenericParamDefs.size() == 0) { @@ -8054,15 +8059,15 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula if ((commonOuterType != NULL) && (mCurTypeInstance->IsGenericTypeInstance())) { - auto parentTypeInstance = (BfGenericTypeInstance*)mCurTypeInstance; + auto parentTypeInstance = (BfTypeInstance*)mCurTypeInstance; if (parentTypeInstance->IsTypeAlias()) - parentTypeInstance = (BfGenericTypeInstance*)GetOuterType(parentTypeInstance)->ToTypeInstance(); + parentTypeInstance = (BfTypeInstance*)GetOuterType(parentTypeInstance)->ToTypeInstance(); for (int i = 0; i < startDefGenericParamIdx; i++) { - genericTypeInst->mGenericParams.push_back(parentTypeInstance->mGenericParams[i]->AddRef()); - genericTypeInst->mTypeGenericArguments.push_back(parentTypeInstance->mTypeGenericArguments[i]); - auto typeGenericArg = genericTypeInst->mTypeGenericArguments[i]; - genericTypeInst->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); + genericTypeInst->mGenericTypeInfo->mGenericParams.push_back(parentTypeInstance->mGenericTypeInfo->mGenericParams[i]->AddRef()); + genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.push_back(parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i]); + auto typeGenericArg = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[i]; + genericTypeInst->mGenericTypeInfo->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); } } @@ -8084,8 +8089,8 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula for (auto genericArgRef : genericArguments) { auto genericArg = genericArgs[genericParamIdx + startDefGenericParamIdx]; - genericTypeInst->mTypeGenericArguments.push_back(genericArg); - genericTypeInst->mTypeGenericArgumentRefs.push_back(genericArgRef); + genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.push_back(genericArg); + genericTypeInst->mGenericTypeInfo->mTypeGenericArgumentRefs.push_back(genericArgRef); genericParamIdx++; } @@ -8148,31 +8153,33 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula names.push_back(fieldName); } + if ((mCurTypeInstance == NULL) || (!mCurTypeInstance->IsGenericTypeInstance())) + wantGeneric = false; + auto baseType = (BfTypeInstance*)ResolveTypeDef(mContext->mCompiler->mValueTypeTypeDef, BfPopulateType_Identity); BfTypeInstance* tupleType = NULL; if (wantGeneric) { - BfGenericTupleType* actualTupleType = new BfGenericTupleType(); + BfTupleType* actualTupleType = new BfTupleType(); + actualTupleType->mGenericTypeInfo = new BfGenericTypeInfo(); actualTupleType->Init(baseType->mTypeDef->mProject, baseType); for (int fieldIdx = 0; fieldIdx < (int)types.size(); fieldIdx++) { BfFieldDef* fieldDef = actualTupleType->AddField(names[fieldIdx]); fieldDef->mProtection = (names[fieldIdx][0] == '_') ? BfProtection_Private : BfProtection_Public; } - actualTupleType->Finish(); - - if (mCurTypeInstance->IsGenericTypeInstance()) + actualTupleType->Finish(); + auto parentTypeInstance = (BfTypeInstance*)mCurTypeInstance; + for (int i = 0; i < parentTypeInstance->mGenericTypeInfo->mGenericParams.size(); i++) { - auto parentTypeInstance = (BfGenericTypeInstance*)mCurTypeInstance; - for (int i = 0; i < parentTypeInstance->mGenericParams.size(); i++) - { - actualTupleType->mGenericParams.push_back(parentTypeInstance->mGenericParams[i]->AddRef()); - actualTupleType->mTypeGenericArguments.push_back(parentTypeInstance->mTypeGenericArguments[i]); - auto typeGenericArg = actualTupleType->mTypeGenericArguments[i]; - actualTupleType->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); - } - CheckUnspecializedGenericType(actualTupleType, populateType); + actualTupleType->mGenericTypeInfo->mGenericParams.push_back(parentTypeInstance->mGenericTypeInfo->mGenericParams[i]->AddRef()); + actualTupleType->mGenericTypeInfo->mTypeGenericArguments.push_back(parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i]); + auto typeGenericArg = actualTupleType->mGenericTypeInfo->mTypeGenericArguments[i]; + actualTupleType->mGenericTypeInfo->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); } + CheckUnspecializedGenericType(actualTupleType, populateType); + actualTupleType->mIsUnspecializedType = actualTupleType->mGenericTypeInfo->mIsUnspecialized; + actualTupleType->mIsUnspecializedTypeVariation = actualTupleType->mGenericTypeInfo->mIsUnspecializedVariation; tupleType = actualTupleType; } else @@ -8216,13 +8223,14 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula return ResolveTypeResult(typeRef, NULL, populateType, resolveFlags); } - BfGenericTypeInstance* genericTypeInst = new BfGenericTypeInstance(); + BfTypeInstance* genericTypeInst = new BfTypeInstance(); + genericTypeInst->mGenericTypeInfo = new BfGenericTypeInfo(); genericTypeInst->mContext = mContext; genericTypeInst->mTypeDef = typeDef; auto genericParamInstance = new BfGenericTypeParamInstance(typeDef, 0); - genericTypeInst->mGenericParams.push_back(genericParamInstance); - genericTypeInst->mTypeGenericArguments.push_back(elementType); + genericTypeInst->mGenericTypeInfo->mGenericParams.push_back(genericParamInstance); + genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.push_back(elementType); //genericTypeInst->mIsUnspecialized = elementType->IsGenericParam() || elementType->IsUnspecializedType(); CheckUnspecializedGenericType(genericTypeInst, populateType); @@ -8311,22 +8319,21 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula BfTypeInstance* delegateType = NULL; if (wantGeneric) { - BfGenericTypeInstance* genericTypeInst = new BfGenericDelegateType(); + BfDelegateType* genericTypeInst = new BfDelegateType(); + genericTypeInst->mGenericTypeInfo = new BfGenericTypeInfo(); delegateType = genericTypeInst; - delegateInfo = delegateType->GetDelegateInfo(); - - if (mCurTypeInstance->IsGenericTypeInstance()) - { - auto parentTypeInstance = (BfGenericTypeInstance*)mCurTypeInstance; - for (int i = 0; i < parentTypeInstance->mGenericParams.size(); i++) - { - genericTypeInst->mGenericParams.push_back(parentTypeInstance->mGenericParams[i]->AddRef()); - genericTypeInst->mTypeGenericArguments.push_back(parentTypeInstance->mTypeGenericArguments[i]); - auto typeGenericArg = genericTypeInst->mTypeGenericArguments[i]; - genericTypeInst->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); - } - CheckUnspecializedGenericType(genericTypeInst, populateType); + delegateInfo = delegateType->GetDelegateInfo(); + auto parentTypeInstance = (BfTypeInstance*)mCurTypeInstance; + for (int i = 0; i < parentTypeInstance->mGenericTypeInfo->mGenericParams.size(); i++) + { + genericTypeInst->mGenericTypeInfo->mGenericParams.push_back(parentTypeInstance->mGenericTypeInfo->mGenericParams[i]->AddRef()); + genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.push_back(parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i]); + auto typeGenericArg = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[i]; + genericTypeInst->mGenericTypeInfo->mIsUnspecialized |= typeGenericArg->IsGenericParam() || typeGenericArg->IsUnspecializedType(); } + CheckUnspecializedGenericType(genericTypeInst, populateType); + genericTypeInst->mIsUnspecializedType = genericTypeInst->mGenericTypeInfo->mIsUnspecialized; + genericTypeInst->mIsUnspecializedTypeVariation = genericTypeInst->mGenericTypeInfo->mIsUnspecializedVariation; } else { @@ -8520,32 +8527,32 @@ BfType* BfModule::ResolveTypeRefAllowUnboundGenerics(BfTypeReference* typeRef, B } // This finds non-default unspecialized generic type instances and converts them into a BfUnspecializedGenericTypeVariation -BfType* BfModule::CheckUnspecializedGenericType(BfGenericTypeInstance* genericTypeInst, BfPopulateType populateType) +BfType* BfModule::CheckUnspecializedGenericType(BfTypeInstance* genericTypeInst, BfPopulateType populateType) { - int argCount = (int)genericTypeInst->mTypeGenericArguments.size(); + int argCount = (int)genericTypeInst->mGenericTypeInfo->mTypeGenericArguments.size(); bool isDefaultUnspecialized = true; for (int argIdx = 0; argIdx < argCount; argIdx++) { - auto argType = genericTypeInst->mTypeGenericArguments[argIdx]; + auto argType = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[argIdx]; if (argType->IsGenericParam()) { auto genericParamType = (BfGenericParamType*)argType; if ((genericParamType->mGenericParamKind != BfGenericParamKind_Type) || (genericParamType->mGenericParamIdx != argIdx)) isDefaultUnspecialized = false; - genericTypeInst->mIsUnspecialized = true; + genericTypeInst->mGenericTypeInfo->mIsUnspecialized = true; } else if (argType->IsUnspecializedType()) { isDefaultUnspecialized = false; - genericTypeInst->mIsUnspecialized = true; + genericTypeInst->mGenericTypeInfo->mIsUnspecialized = true; } else isDefaultUnspecialized = false; } - if (genericTypeInst->mIsUnspecialized) - genericTypeInst->mIsUnspecializedVariation = !isDefaultUnspecialized; + if (genericTypeInst->mGenericTypeInfo->mIsUnspecialized) + genericTypeInst->mGenericTypeInfo->mIsUnspecializedVariation = !isDefaultUnspecialized; return genericTypeInst; } @@ -8556,7 +8563,7 @@ BfTypeInstance* BfModule::GetUnspecializedTypeInstance(BfTypeInstance* typeInst) BF_ASSERT((!typeInst->IsDelegateFromTypeRef()) && (!typeInst->IsFunctionFromTypeRef())); - auto genericTypeInst = (BfGenericTypeInstance*)typeInst; + auto genericTypeInst = (BfTypeInstance*)typeInst; auto result = ResolveTypeDef(genericTypeInst->mTypeDef, BfPopulateType_Declaration); BF_ASSERT((result != NULL) && (result->IsUnspecializedType())); if (result == NULL) @@ -9249,8 +9256,8 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp if (ignoreWrites) return mBfIRBuilder->GetFakeVal(); - auto fromNullableType = (BfGenericTypeInstance*)typedVal.mType; - auto toNullableType = (BfGenericTypeInstance*)toType; + auto fromNullableType = (BfTypeInstance*)typedVal.mType; + auto toNullableType = (BfTypeInstance*)toType; BfIRValue srcPtr = typedVal.mValue; if (!typedVal.IsAddr()) @@ -9263,7 +9270,8 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp auto srcAddr = mBfIRBuilder->CreateInBoundsGEP(srcPtr, 0, 1); // mValue auto srcVal = mBfIRBuilder->CreateLoad(srcAddr); - auto toVal = CastToValue(srcNode, BfTypedValue(srcVal, fromNullableType->mTypeGenericArguments[0]), toNullableType->mTypeGenericArguments[0], ignoreErrors ? BfCastFlags_SilentFail : BfCastFlags_None); + auto toVal = CastToValue(srcNode, BfTypedValue(srcVal, fromNullableType->mGenericTypeInfo->mTypeGenericArguments[0]), + toNullableType->mGenericTypeInfo->mTypeGenericArguments[0], ignoreErrors ? BfCastFlags_SilentFail : BfCastFlags_None); if (!toVal) return BfIRValue(); @@ -9915,8 +9923,8 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp // Check type generic constraints if ((mCurTypeInstance != NULL) && (mCurTypeInstance->IsGenericTypeInstance()) && (mCurTypeInstance->IsUnspecializedType())) { - auto genericTypeInst = (BfGenericTypeInstance*)mCurTypeInstance; - for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericParams.size(); genericParamIdx++) + auto genericTypeInst = (BfTypeInstance*)mCurTypeInstance; + for (int genericParamIdx = 0; genericParamIdx < genericTypeInst->mGenericTypeInfo->mGenericParams.size(); genericParamIdx++) { auto genericParam = GetGenericTypeParamInstance(genericParamIdx); for (auto& opConstraint : genericParam->mOperatorConstraints) @@ -10608,19 +10616,19 @@ bool BfModule::IsTypeMoreSpecific(BfType* leftType, BfType* rightType) if (!rightType->IsGenericTypeInstance()) return true; - auto leftGenericType = (BfGenericTypeInstance*)leftType; - auto rightGenericType = (BfGenericTypeInstance*)rightType; + auto leftGenericType = (BfTypeInstance*)leftType; + auto rightGenericType = (BfTypeInstance*)rightType; if (leftGenericType->mTypeDef != rightGenericType->mTypeDef) return false; bool isBetter = false; bool isWorse = false; - for (int argIdx = 0; argIdx < (int)leftGenericType->mTypeGenericArguments.size(); argIdx++) + for (int argIdx = 0; argIdx < (int)leftGenericType->mGenericTypeInfo->mTypeGenericArguments.size(); argIdx++) { - if (IsTypeMoreSpecific(leftGenericType->mTypeGenericArguments[argIdx], rightGenericType->mTypeGenericArguments[argIdx])) + if (IsTypeMoreSpecific(leftGenericType->mGenericTypeInfo->mTypeGenericArguments[argIdx], rightGenericType->mGenericTypeInfo->mTypeGenericArguments[argIdx])) isBetter = true; - if (IsTypeMoreSpecific(rightGenericType->mTypeGenericArguments[argIdx], leftGenericType->mTypeGenericArguments[argIdx])) + if (IsTypeMoreSpecific(rightGenericType->mGenericTypeInfo->mTypeGenericArguments[argIdx], leftGenericType->mGenericTypeInfo->mTypeGenericArguments[argIdx])) isWorse = true; } @@ -10713,7 +10721,7 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF else if ((resolvedType->IsArray()) && ((typeNameFlags & BfTypeNameFlag_UseArrayImplType) == 0)) { auto arrayType = (BfArrayType*)resolvedType; - DoTypeToString(str, arrayType->mTypeGenericArguments[0], typeNameFlags, genericMethodNameOverrides); + DoTypeToString(str, arrayType->mGenericTypeInfo->mTypeGenericArguments[0], typeNameFlags, genericMethodNameOverrides); str += "["; for (int i = 1; i < arrayType->mDimensions; i++) str += ","; @@ -10722,8 +10730,8 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF } else if (resolvedType->IsNullable()) { - auto genericType = (BfGenericTypeInstance*)resolvedType; - auto elementType = genericType->mTypeGenericArguments[0]; + auto genericType = (BfTypeInstance*)resolvedType; + auto elementType = genericType->mGenericTypeInfo->mTypeGenericArguments[0]; DoTypeToString(str, elementType, typeNameFlags, genericMethodNameOverrides); str += "?"; return; @@ -10954,13 +10962,13 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF if (resolvedType->IsGenericTypeInstance()) { - auto genericTypeInst = (BfGenericTypeInstance*)resolvedType; + auto genericTypeInst = (BfTypeInstance*)resolvedType; if (prevGenericParamCount != (int)checkTypeDef->mGenericParamDefs.size()) { str += '<'; for (int i = prevGenericParamCount; i < (int)checkTypeDef->mGenericParamDefs.size(); i++) { - BfType* typeGenericArg = genericTypeInst->mTypeGenericArguments[i]; + BfType* typeGenericArg = genericTypeInst->mGenericTypeInfo->mTypeGenericArguments[i]; if (typeGenericArg->IsGenericParam()) { if ((typeNameFlags & BfTypeNameFlag_ResolveGenericParamNames) == 0) diff --git a/IDEHelper/Compiler/BfResolvedTypeUtils.cpp b/IDEHelper/Compiler/BfResolvedTypeUtils.cpp index 9763b5e2..f72bcd46 100644 --- a/IDEHelper/Compiler/BfResolvedTypeUtils.cpp +++ b/IDEHelper/Compiler/BfResolvedTypeUtils.cpp @@ -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) -{ - BfTypeInstance::ReportMemory(memReporter); - memReporter->Add(sizeof(BfGenericTypeInstance) - sizeof(BfTypeInstance)); +void BfGenericTypeInfo::ReportMemory(MemReporter* memReporter) +{ + 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(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())) + if ((rhs->IsNamedTypeReference()) || (rhs->IsA()) || (rhs->IsA())) { 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 { diff --git a/IDEHelper/Compiler/BfResolvedTypeUtils.h b/IDEHelper/Compiler/BfResolvedTypeUtils.h index ea8d02ed..d9de045f 100644 --- a/IDEHelper/Compiler/BfResolvedTypeUtils.h +++ b/IDEHelper/Compiler/BfResolvedTypeUtils.h @@ -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 mGenericParams; + bool mConstraintsPassed; + +public: + BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) : + mGenericParams(std::move(prev.mGenericParams)), + mConstraintsPassed(prev.mConstraintsPassed) + { + } + + BfGenericExtensionEntry() + { + mConstraintsPassed = true; + } + ~BfGenericExtensionEntry(); +}; + +class BfGenericExtensionInfo +{ +public: + Dictionary mExtensionMap; +}; + +// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so +// class ClassA { class ClassB {} } will create a ClassA.ClassB +class BfGenericTypeInfo +{ +public: + typedef Array GenericParamsVector; + + Array mTypeGenericArgumentRefs; + BfTypeVector mTypeGenericArguments; + GenericParamsVector mGenericParams; + BfGenericExtensionInfo* mGenericExtensionInfo; + bool mIsUnspecialized; + bool mIsUnspecializedVariation; + bool mValidatedGenericConstraints; + bool mHadValidateErrors; + Array 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 mInterfaces; Array 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 mGenericParams; - bool mConstraintsPassed; - -public: - BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) : - mGenericParams(std::move(prev.mGenericParams)), - mConstraintsPassed(prev.mConstraintsPassed) - { - } - - BfGenericExtensionEntry() - { - mConstraintsPassed = true; - } - ~BfGenericExtensionEntry(); -}; - -class BfGenericExtensionInfo -{ -public: - Dictionary mExtensionMap; -}; - -// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so -// class ClassA { class ClassB {} } will create a ClassA.ClassB -class BfGenericTypeInstance : public BfTypeInstance -{ -public: - typedef Array GenericParamsVector; - - Array mTypeGenericArgumentRefs; - BfTypeVector mTypeGenericArguments; - GenericParamsVector mGenericParams; - BfGenericExtensionInfo* mGenericExtensionInfo; - bool mIsUnspecialized; - bool mIsUnspecializedVariation; - bool mValidatedGenericConstraints; - bool mHadValidateErrors; - Array 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); } diff --git a/IDEHelper/Compiler/BfStmtEvaluator.cpp b/IDEHelper/Compiler/BfStmtEvaluator.cpp index 7a9190cb..7e4000c3 100644 --- a/IDEHelper/Compiler/BfStmtEvaluator.cpp +++ b/IDEHelper/Compiler/BfStmtEvaluator.cpp @@ -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) diff --git a/IDEHelper/DbgExprEvaluator.cpp b/IDEHelper/DbgExprEvaluator.cpp index c21404a7..ac21315e 100644 --- a/IDEHelper/DbgExprEvaluator.cpp +++ b/IDEHelper/DbgExprEvaluator.cpp @@ -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; diff --git a/IDEHelper/Tests/src/Aliases.bf b/IDEHelper/Tests/src/Aliases.bf index 1c80bc17..bbf92e82 100644 --- a/IDEHelper/Tests/src/Aliases.bf +++ b/IDEHelper/Tests/src/Aliases.bf @@ -19,6 +19,9 @@ namespace Tests public typealias AliasA5 = (int, T); public typealias AliasA6 = (T, T2); + public typealias AliasA7 = T[]; + public typealias AliasA8 = T[3]; + public delegate T Zag(); } @@ -31,6 +34,10 @@ namespace Tests ClassA.AliasA6 t0 = (default(T), 1.2f); ClassA.AliasA4 dlg0 = scope => LocalA; + + ClassA.AliasA7 arr0 = scope T[123]; + T[3] arr1 = .(default, default, default); + ClassA.AliasA8 arr2 = arr1; } [Test]