Refactored generic type instances to be a BfGenericTypeInfo member

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);
 					}										
 				}
 			}

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";
 			}
 		}

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;
 				}
 			}

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);
 	}
 }

IDEHelper/Compiler/BfContext.h

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

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)

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())

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;

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<int, int>& usedStrin
 		SizedArray<BfIRValue, 4> unspecializedData =
 		{
 			typeInstanceData,			
-			GetConstValue((int)genericTypeInstance->mTypeGenericArguments.size(), byteType), // mGenericParamCount			
+			GetConstValue((int)genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments.size(), byteType), // mGenericParamCount			
 		};
 		auto reflectUnspecializedGenericType = ResolveTypeDef(mCompiler->mReflectUnspecializedGenericType);
 		typeInstanceDataType = mBfIRBuilder->MapTypeInst(reflectUnspecializedGenericType->ToTypeInstance(), BfIRPopulateType_Full);
@@ -6160,7 +6160,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
 		auto unspecializedType = ResolveTypeDef(typeInstance->mTypeDef);
 
 		SizedArray<BfIRValue, 4> resolvedTypes;
-		for (auto typeGenericArg : genericTypeInstance->mTypeGenericArguments)
+		for (auto typeGenericArg : genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
 			resolvedTypes.push_back(GetConstValue(typeGenericArg->mTypeId, typeIdType));
 
 		auto typeIRType = mBfIRBuilder->MapType(typeIdType);
@@ -6185,7 +6185,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
 		{
 			auto arrayType = (BfArrayType*)typeInstance;
 
-			BfType* elementType = genericTypeInstance->mTypeGenericArguments[0];
+			BfType* elementType = genericTypeInstance->mGenericTypeInfo->mTypeGenericArguments[0];
 			BfFieldInstance* elementFieldInstance = &genericTypeInstance->mFieldInstances[0];
 
 			SizedArray<BfIRValue, 4> arrayData  =
@@ -6911,12 +6911,12 @@ bool BfModule::CheckGenericConstraints(const BfGenericParamSource& genericParamS
 					auto sizedArrayType = (BfSizedArrayType*)origCheckArgType;
 					if (convCheckConstraint->IsGenericTypeInstance())
 					{
-						auto convCheckConstraintInst = (BfGenericTypeInstance*)convCheckConstraint;
+						auto convCheckConstraintInst = (BfTypeInstance*)convCheckConstraint;
 						if (convCheckConstraintInst->mTypeDef == mCompiler->mSizedArrayTypeDef)
 						{
-							if (convCheckConstraintInst->mTypeGenericArguments[0] == sizedArrayType->mElementType)
+							if (convCheckConstraintInst->mGenericTypeInfo->mTypeGenericArguments[0] == sizedArrayType->mElementType)
 							{
-								auto constExprValueType = (BfConstExprValueType*)convCheckConstraintInst->mTypeGenericArguments[1];
+								auto constExprValueType = (BfConstExprValueType*)convCheckConstraintInst->mGenericTypeInfo->mTypeGenericArguments[1];
 								if (sizedArrayType->mElementCount == constExprValueType->mValue.mInt64)
 									constraintMatched = true;
 							}							
@@ -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];
 		}		
 	}
 

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<int>* outVals, SizedArrayImpl<BfTypeInstance*>* exChecks, bool isInterfacePass);
-	BfType* CheckUnspecializedGenericType(BfGenericTypeInstance* genericTypeInst, BfPopulateType populateType);
+	BfType* CheckUnspecializedGenericType(BfTypeInstance* genericTypeInst, BfPopulateType populateType);
 	BfTypeInstance* GetUnspecializedTypeInstance(BfTypeInstance* typeInst);
 	BfArrayType* CreateArrayType(BfType* resolvedType, int dimensions);
 	BfSizedArrayType* CreateSizedArrayType(BfType* resolvedType, int size);

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<BfGenericInstanceTypeRef>(rhs);
 	if (rhsGenericTypeInstRef == NULL)
@@ -3072,7 +3033,7 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
 					return false;
 
 				auto rhsElemType = ctx->mModule->ResolveTypeRef(rhsNullableTypeRef->mElementType, BfPopulateType_Identity, ctx->mResolveFlags);
-				return lhsGenericType->mTypeGenericArguments[0] == rhsElemType;
+				return lhsGenericType->mGenericTypeInfo->mTypeGenericArguments[0] == rhsElemType;
 			}
 		}
 
@@ -3089,11 +3050,11 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
 					checkTypeInstance = checkTypeInstance->GetUnderlyingType()->ToTypeInstance();
 				BF_ASSERT(checkTypeInstance->IsGenericTypeInstance());
 				int numParentGenericParams = (int) commonOuterType->mGenericParamDefs.size();
-				auto curTypeInstance = (BfGenericTypeInstance*)checkTypeInstance;
-				if (lhsGenericType->mTypeGenericArguments.size() != numParentGenericParams)
+				auto curTypeInstance = (BfTypeInstance*)checkTypeInstance;
+				if (lhsGenericType->mGenericTypeInfo->mTypeGenericArguments.size() != numParentGenericParams)
 					return false;
 				for (int i = 0; i < (int) numParentGenericParams; i++)
-					if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mTypeGenericArguments[i])
+					if ((*lhsTypeGenericArguments)[i] != curTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i])
 						return false;
 				return true;
 			}
@@ -3120,12 +3081,12 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfGenericTypeInstance* lhsGenericType,
 		BfTypeDef* commonOuterType = ctx->mModule->FindCommonOuterType(ctx->mModule->mCurTypeInstance->mTypeDef, elementTypeDef->mOuterType);
 		if (commonOuterType != NULL)
 		{
-			auto parentTypeInstance = (BfGenericTypeInstance*)ctx->mModule->mCurTypeInstance;
+			auto parentTypeInstance = (BfTypeInstance*)ctx->mModule->mCurTypeInstance;
 			genericParamOffset = (int) commonOuterType->mGenericParamDefs.size();
 			for (int i = 0; i < genericParamOffset; i++)
-				for (auto genericArg : parentTypeInstance->mTypeGenericArguments)
+				for (auto genericArg : parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments)
 				{
-				if (parentTypeInstance->mTypeGenericArguments[i] != (*lhsTypeGenericArguments)[i])
+				if (parentTypeInstance->mGenericTypeInfo->mTypeGenericArguments[i] != (*lhsTypeGenericArguments)[i])
 					return false;
 				}
 		}
@@ -3193,7 +3154,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
 		}
 	}
 
- 	if ((rhs->IsNamedTypeReference()) || (rhs->IsA<BfGenericInstanceTypeRef>()))
+ 	if ((rhs->IsNamedTypeReference()) || (rhs->IsA<BfGenericInstanceTypeRef>()) || (rhs->IsA<BfQualifiedTypeReference>()))
 	{
 		if ((ctx->mRootTypeRef != rhs) || (ctx->mRootTypeDef == NULL))
 		{
@@ -3235,7 +3196,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
 		BfArrayType* lhsArrayType = (BfArrayType*) lhs;
 		if (lhsArrayType->mDimensions != rhsArrayTypeRef->mDimensions)
 			return false;
-		return Equals(lhsArrayType->mTypeGenericArguments[0], rhsArrayTypeRef->mElementType, ctx);
+		return Equals(lhsArrayType->mGenericTypeInfo->mTypeGenericArguments[0], rhsArrayTypeRef->mElementType, ctx);
 	}
 	else if (lhs->IsDelegateFromTypeRef() || lhs->IsFunctionFromTypeRef())
 	{
@@ -3319,8 +3280,8 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
 			if (rhsType != NULL)
 				return lhs == rhsType;
 
-			BfGenericTypeInstance* lhsGenericType = (BfGenericTypeInstance*) lhs;
-			return GenericTypeEquals(lhsGenericType, &lhsGenericType->mTypeGenericArguments, rhs, rhsTypeDef, ctx);
+			BfTypeInstance* lhsGenericType = (BfTypeInstance*) lhs;
+			return GenericTypeEquals(lhsGenericType, &lhsGenericType->mGenericTypeInfo->mTypeGenericArguments, rhs, rhsTypeDef, ctx);
 		}		
 		else
 		{

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<BfGenericTypeParamInstance*> mGenericParams;
+	bool mConstraintsPassed;
+
+public:
+	BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) :
+		mGenericParams(std::move(prev.mGenericParams)),
+		mConstraintsPassed(prev.mConstraintsPassed)
+	{
+	}
+
+	BfGenericExtensionEntry()
+	{
+		mConstraintsPassed = true;
+	}
+	~BfGenericExtensionEntry();
+};
+
+class BfGenericExtensionInfo
+{
+public:
+	Dictionary<BfTypeDef*, BfGenericExtensionEntry> mExtensionMap;
+};
+
+// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so
+// class ClassA<T> { class ClassB<T2> {} } will create a ClassA.ClassB<T, T2>
+class BfGenericTypeInfo
+{
+public:
+	typedef Array<BfGenericTypeParamInstance*> GenericParamsVector;
+
+	Array<BfTypeReference*> mTypeGenericArgumentRefs;
+	BfTypeVector mTypeGenericArguments;
+	GenericParamsVector mGenericParams;
+	BfGenericExtensionInfo* mGenericExtensionInfo;
+	bool mIsUnspecialized;
+	bool mIsUnspecializedVariation;
+	bool mValidatedGenericConstraints;
+	bool mHadValidateErrors;
+	Array<BfProject*> mProjectsReferenced; // Generic methods that only refer to these projects don't need a specialized extension
+
+public:
+	BfGenericTypeInfo()
+	{
+		mGenericExtensionInfo = NULL;
+		mHadValidateErrors = false;
+		mIsUnspecialized = false;
+		mIsUnspecializedVariation = false;
+		mValidatedGenericConstraints = false;
+	}
+
+	~BfGenericTypeInfo();
+	
+	void ReportMemory(MemReporter* memReporter);
+};
+
+
 // Instance of struct or class
 class BfTypeInstance : public BfDependedType
 {
@@ -1625,6 +1685,7 @@ public:
 	BfCustomAttributes* mCustomAttributes;
 	BfAttributeData* mAttributeData;
 	BfTypeInfoEx* mTypeInfoEx;
+	BfGenericTypeInfo* mGenericTypeInfo;
 
 	Array<BfTypeInterfaceEntry> mInterfaces;	
 	Array<BfTypeInterfaceMethodEntry> mInterfaceMethodTable;
@@ -1690,6 +1751,7 @@ public:
 		mCustomAttributes = NULL;
 		mAttributeData = NULL;
 		mTypeInfoEx = NULL;
+		mGenericTypeInfo = NULL;
 		//mClassVData = NULL;
 		mVirtualMethodTableSize = 0;
 		mHotTypeData = NULL;		
@@ -1767,6 +1829,18 @@ public:
 	virtual bool WantsGCMarking() override;
 	virtual BfTypeCode GetLoweredType() override;
 
+	BfGenericTypeInfo* GetGenericTypeInfo() { return mGenericTypeInfo; }
+ 
+	virtual BfTypeInstance* ToGenericTypeInstance() { return (mGenericTypeInfo != NULL) ? this : NULL; }
+ 	virtual bool IsGenericTypeInstance() override { return mGenericTypeInfo != NULL; }
+ 	virtual bool IsSpecializedType() override { return (mGenericTypeInfo != NULL) && (!mGenericTypeInfo->mIsUnspecialized); }
+ 	virtual bool IsSpecializedByAutoCompleteMethod() override;
+ 	virtual bool IsUnspecializedType() override { return (mGenericTypeInfo != NULL) && (mGenericTypeInfo->mIsUnspecialized); }
+ 	virtual bool IsUnspecializedTypeVariation() override { return (mGenericTypeInfo != NULL) && (mGenericTypeInfo->mIsUnspecializedVariation); }
+ 	virtual bool IsNullable() override;
+ 	virtual bool HasVarConstraints();	
+ 	virtual bool IsTypeMemberIncluded(BfTypeDef* declaringTypeDef, BfTypeDef* activeTypeDef = NULL, BfModule* module = NULL) override;
+
 	virtual BfTypeInstance* GetImplBaseType() { return mBaseType; }
 
 	virtual bool IsIRFuncUsed(BfIRFunction func);
@@ -1786,6 +1860,8 @@ public:
 	int GetInstStride() { return BF_ALIGN(mInstSize, mInstAlign); }
 	bool HasOverrideMethods();	
 	bool GetResultInfo(BfType*& valueType, int& okTagId);
+	BfGenericTypeInfo::GenericParamsVector* GetGenericParamsVector(BfTypeDef* declaringTypeDef);
+	void GenerateProjectsReferenced();
 
 	virtual void ReportMemory(MemReporter* memReporter) override;
 };
@@ -1856,7 +1932,7 @@ public:
 	virtual bool IsDependentOnUnderlyingType() override { return true; }
 	virtual BfType* GetUnderlyingType() override { return mElementType; }
 	
-	virtual BfGenericTypeInstance* ToGenericTypeInstance() override { return mElementType->ToGenericTypeInstance(); }
+	virtual BfTypeInstance* ToGenericTypeInstance() override { return mElementType->ToGenericTypeInstance(); }
 	virtual bool IsSpecializedType() override { return !mElementType->IsUnspecializedType(); }
 	virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); }
 	virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedTypeVariation(); }		
@@ -1871,79 +1947,6 @@ public:
 	BfType* GetModifiedElementType();
 };
 
-class BfGenericExtensionEntry
-{
-public:	
-	Array<BfGenericTypeParamInstance*> mGenericParams;
-	bool mConstraintsPassed;	
-
-public:
-	BfGenericExtensionEntry(BfGenericExtensionEntry&& prev) : 
-		mGenericParams(std::move(prev.mGenericParams)),
-		mConstraintsPassed(prev.mConstraintsPassed)
-	{
-	}
-
-	BfGenericExtensionEntry()
-	{
-		mConstraintsPassed = true;
-	}
-	~BfGenericExtensionEntry();	
-};
-
-class BfGenericExtensionInfo
-{
-public:	
-	Dictionary<BfTypeDef*, BfGenericExtensionEntry> mExtensionMap;
-};
-
-// Note on nested generic types- mGenericParams is the accumulation of all generic params from outer to inner, so
-// class ClassA<T> { class ClassB<T2> {} } will create a ClassA.ClassB<T, T2>
-class BfGenericTypeInstance : public BfTypeInstance
-{
-public:
-	typedef Array<BfGenericTypeParamInstance*> GenericParamsVector;
-
-	Array<BfTypeReference*> mTypeGenericArgumentRefs;
-	BfTypeVector mTypeGenericArguments;
-	GenericParamsVector mGenericParams;
-	BfGenericExtensionInfo* mGenericExtensionInfo;
-	bool mIsUnspecialized;
-	bool mIsUnspecializedVariation;
-	bool mValidatedGenericConstraints;
-	bool mHadValidateErrors;		
-	Array<BfProject*> mProjectsReferenced; // Generic methods that only refer to these projects don't need a specialized extension
-
-public:
-	BfGenericTypeInstance()
-	{
-		mGenericExtensionInfo = NULL;
-		mHadValidateErrors = false;
-		mIsUnspecialized = false;
-		mIsUnspecializedVariation = false;
-		mValidatedGenericConstraints = false;
-	}
-
-	~BfGenericTypeInstance();	
-
-	GenericParamsVector* GetGenericParamsVector(BfTypeDef* declaringTypeDef);	
-	void GenerateProjectsReferenced();
-
-	virtual BfGenericTypeInstance* ToGenericTypeInstance() override { return this; }	
-
-	virtual bool IsGenericTypeInstance() override { return true; }	
-	virtual bool IsSpecializedType() override { return !mIsUnspecialized; }
-	virtual bool IsSpecializedByAutoCompleteMethod() override;
-	virtual bool IsUnspecializedType() override { return mIsUnspecialized; }
-	virtual bool IsUnspecializedTypeVariation() override { return mIsUnspecializedVariation; }
-	virtual bool IsNullable() override;
-	virtual bool HasVarConstraints();
-	virtual BfType* GetUnderlyingType() override { return mIsTypedPrimitive ? BfTypeInstance::GetUnderlyingType() : mTypeGenericArguments[0]; }
-	virtual bool IsTypeMemberIncluded(BfTypeDef* declaringTypeDef, BfTypeDef* activeTypeDef, BfModule* module) override;	
-
-	virtual void ReportMemory(MemReporter* memReporter) override;
-};
-
 class BfTypeAliasType : public BfTypeInstance
 {
 public:
@@ -1957,22 +1960,6 @@ public:
 
 	virtual bool IsTypeAlias() override { return true; }	
 	virtual BfType* GetUnderlyingType() override { return mAliasToType; }
-};
-
-class BfGenericTypeAliasType : public BfGenericTypeInstance
-{
-public:
-	BfType* mAliasToType;
-
-public:
-	BfGenericTypeAliasType()
-	{
-		mAliasToType = NULL;
-	}
-
-	virtual bool IsTypeAlias() override { return true; }	
-	virtual BfType* GetUnderlyingType() override { return mAliasToType; }
-
 	virtual bool WantsGCMarking() override { return mAliasToType->WantsGCMarking(); }
 };
 
@@ -2036,28 +2023,6 @@ public:
 	virtual BfDelegateInfo* GetDelegateInfo() { return &mDelegateInfo; }
 };
 
-class BfGenericDelegateType : public BfGenericTypeInstance
-{
-public:	
-	BfDelegateInfo mDelegateInfo;
-
-public:
-	BfGenericDelegateType()
-	{		
-		
-	}	
-
-	virtual bool IsOnDemand() override { return true; }
-
-	virtual bool IsDelegate() override { return mTypeDef->mIsDelegate; }
-	virtual bool IsDelegateFromTypeRef() override { return mTypeDef->mIsDelegate; }
-
-	virtual bool IsFunction() override { return !mTypeDef->mIsDelegate; }
-	virtual bool IsFunctionFromTypeRef() override { return !mTypeDef->mIsDelegate; }
-	
-	virtual BfDelegateInfo* GetDelegateInfo() override { return &mDelegateInfo; }	
-};
-
 class BfTupleType : public BfTypeInstance
 {
 public:		
@@ -2082,25 +2047,6 @@ public:
 	virtual bool IsUnspecializedTypeVariation() override { return mIsUnspecializedTypeVariation; }
 };
 
-class BfGenericTupleType : public BfGenericTypeInstance
-{
-public:
-	bool mCreatedTypeDef;
-	String mNameAdd;
-	BfSource* mSource;
-	
-public:
-	BfGenericTupleType();
-	~BfGenericTupleType();
-
-	void Init(BfProject* bfProject, BfTypeInstance* valueTypeInstance);
-	BfFieldDef* AddField(const StringImpl& name);
-	void Finish();
-
-	virtual bool IsOnDemand() override { return true; }
-	virtual bool IsTuple() override { return true; }
-};
-
 class BfConcreteInterfaceType : public BfType
 {
 public:
@@ -2213,7 +2159,7 @@ public:
 	virtual bool IsValuelessType() override { return mElementType->IsValuelessType(); }		
 };
 
-class BfArrayType : public BfGenericTypeInstance
+class BfArrayType : public BfTypeInstance
 {
 public:
 	int mDimensions;
@@ -2391,8 +2337,8 @@ public:
 
 public:
 	static BfVariant EvaluateToVariant(LookupContext* ctx, BfExpression* expr, BfType*& constGenericParam);
-	static bool GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset);
-	static bool GenericTypeEquals(BfGenericTypeInstance* lhsGenericType, BfTypeVector* typeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx);
+	static bool GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* lhsTypeGenericArguments, BfTypeReference* rhs, LookupContext* ctx, int& genericParamOffset);
+	static bool GenericTypeEquals(BfTypeInstance* lhsGenericType, BfTypeVector* typeGenericArguments, BfTypeReference* rhs, BfTypeDef* rhsTypeDef, LookupContext* ctx);
 	static void HashGenericArguments(BfTypeReference* typeRef, LookupContext* ctx, int& hash);
 	static int Hash(BfType* type, LookupContext* ctx, bool allowRef = false);
 	static int DirectHash(BfTypeReference* typeRef, LookupContext* ctx, BfHashFlags flags = BfHashFlag_None);
@@ -2483,7 +2429,7 @@ public:
 			auto genericTypeInst = typeInst->ToGenericTypeInstance();
 			if (genericTypeInst != NULL)
 			{
-				for (auto genericArg : genericTypeInst->mTypeGenericArguments)
+				for (auto genericArg : genericTypeInst->mGenericTypeInfo->mTypeGenericArguments)
 					GetProjectList(genericArg, projectList, immutableLength);
 			}
 

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)

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;
 

IDEHelper/Tests/src/Aliases.bf

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