Fixed extensions issues with changing root def, extending dlg/functions

IDEHelper/Compiler/BfCompiler.cpp

@@ -2954,9 +2954,21 @@ void BfCompiler::UpdateRevisedTypes()
 						continue;
 					}
 
+					// Only allow extending structs and objects
+					if ((checkTypeDef->mTypeCode == BfTypeCode_Struct) || 
+						(checkTypeDef->mTypeCode == BfTypeCode_Object) ||
+						(checkTypeDef->mTypeCode == BfTypeCode_Enum))
+					{
 						rootTypeDef = checkTypeDef;
 						rootTypeDefEntry = checkTypeDefEntry;
+					}
+					
 					checkTypeDefEntry = checkTypeDefEntry->mNext;
+
+					if (compositeTypeDef != NULL)
+					{
+						BF_ASSERT(rootTypeDef->mFullNameEx == compositeTypeDef->mFullNameEx);
+					}
 				}
 			}
 			else if ((outerTypeDef->mIsExplicitPartial) && (!outerTypeDef->mPartialUsed))
@@ -2983,6 +2995,10 @@ void BfCompiler::UpdateRevisedTypes()
 					}
 
 					compositeTypeDef = checkTypeDef;
+					if (rootTypeDef != NULL)
+					{
+						BF_ASSERT(rootTypeDef->mFullNameEx == compositeTypeDef->mFullNameEx);
+					}
 					if (compositeTypeDef->mNextRevision != NULL)
 					{
 						// This is an old 'next revision'
@@ -3004,7 +3020,12 @@ void BfCompiler::UpdateRevisedTypes()
 
 				if (compositeTypeDef == NULL)
 				{
-					if ((rootTypeDef->mIsExplicitPartial) || (rootTypeDefEntry->mNext == NULL) || (!rootTypeDefEntry->mNext->mValue->mIsCombinedPartial))
+					if ((rootTypeDef->mIsExplicitPartial) || (rootTypeDefEntry->mNext == NULL) || 
+						(!rootTypeDefEntry->mNext->mValue->mIsCombinedPartial) ||
+						(rootTypeDefEntry->mNext->mValue->mTypeCode != rootTypeDef->mTypeCode) ||
+						(rootTypeDefEntry->mNext->mValue->mIsFunction != rootTypeDef->mIsFunction) ||
+						(rootTypeDefEntry->mNext->mValue->mIsDelegate != rootTypeDef->mIsDelegate) ||
+						(rootTypeDefEntry->mNext->mValue->mGenericParamDefs.size() != rootTypeDef->mGenericParamDefs.size()))
 					{
 						compositeTypeDef = new BfTypeDef();
 						compositeTypeDef->mSystem = rootTypeDef->mSystem;
@@ -3016,9 +3037,11 @@ void BfCompiler::UpdateRevisedTypes()
 						compositeTypeDef->mNameEx->Ref();
 						compositeTypeDef->mProtection = rootTypeDef->mProtection;
 						compositeTypeDef->mNamespace = rootTypeDef->mNamespace;
-						compositeTypeDef->mTypeCode = BfTypeCode_Extension;
+						compositeTypeDef->mTypeCode = rootTypeDef->mTypeCode;
 						compositeTypeDef->mFullName = rootTypeDef->mFullName;
 						compositeTypeDef->mFullNameEx = rootTypeDef->mFullNameEx;
+						compositeTypeDef->mIsFunction = rootTypeDef->mIsFunction;
+						compositeTypeDef->mIsDelegate = rootTypeDef->mIsDelegate;
 						compositeTypeDef->mIsCombinedPartial = true;
 
 						for (auto prevGenericParam : rootTypeDef->mGenericParamDefs)
@@ -3039,6 +3062,10 @@ void BfCompiler::UpdateRevisedTypes()
 					{
 						BF_ASSERT(rootTypeDefEntry->mNext->mValue->NameEquals(rootTypeDef));
 						compositeTypeDef = rootTypeDefEntry->mNext->mValue;
+						if (rootTypeDef != NULL)
+						{
+							BF_ASSERT(rootTypeDef->mFullNameEx == compositeTypeDef->mFullNameEx);
+						}
 						if (compositeTypeDef->mNextRevision != NULL)
 						{
 							// This is an old 'next revision'
@@ -3168,6 +3195,7 @@ void BfCompiler::UpdateRevisedTypes()
 					if (compositeIsNew)
 					{
 						compositeTypeDef->mDefState = BfTypeDef::DefState_New;
+						compositeTypeDef->mTypeCode = compositeTypeDef->mNextRevision->mTypeCode;
 						mSystem->InjectNewRevision(compositeTypeDef);
 						// Reset 'New' state
 						compositeTypeDef->mDefState = BfTypeDef::DefState_New;
@@ -3261,21 +3289,6 @@ void BfCompiler::UpdateRevisedTypes()
 					}					
 				}
 
-				if (outerTypeDef->mDefState != BfTypeDef::DefState_Deleted)
-					checkMasterTypeDef = outerTypeDef;
-
-				if ((deletedCombinedPartial != NULL) && (checkMasterTypeDef != NULL) &&
-					(deletedCombinedPartial->NameEquals(checkMasterTypeDef)))
-				{
-					// Remap nested types to their master typeDef
-					for (auto nestedType : deletedCombinedPartial->mNestedTypes)
-					{
-						nestedType->mOuterType = checkMasterTypeDef;
-					}
-					deletedCombinedPartial = NULL;
-					checkMasterTypeDef = NULL;
-				}
-
 				outerTypeDefEntry = nextTypeDefEntry;				
 			}
 		}
@@ -3701,7 +3714,8 @@ void BfCompiler::ProcessAutocompleteTempType()
 	typeState.mCurTypeDef = tempTypeDef;
 	SetAndRestoreValue<BfTypeState*> prevTypeState(module->mContext->mCurTypeState, &typeState);	
 
-	BfTypeDef* actualTypeDef = NULL;
+	auto _FindAcutalTypeDef = [&](BfTypeDef* tempTypeDef)
+	{		
 		auto typeName = tempTypeDef->mFullName;
 		int wantNumGenericParams = (int)tempTypeDef->mGenericParamDefs.size();
 		auto actualTypeDefItr = mSystem->mTypeDefs.TryGet(typeName);
@@ -3715,30 +3729,43 @@ void BfCompiler::ProcessAutocompleteTempType()
 					(checkTypeDef->mGenericParamDefs.size() == tempTypeDef->mGenericParamDefs.size()) &&
 					(tempTypeDef->mProject->ContainsReference(checkTypeDef->mProject)))
 				{
-				actualTypeDef = mSystem->FilterDeletedTypeDef(checkTypeDef);
+					return mSystem->FilterDeletedTypeDef(checkTypeDef);					
-				break;
 				}
 
 				if ((checkTypeDef->mGenericParamDefs.size() == wantNumGenericParams) &&
 					(FileNameEquals(tempTypeDef->mSource->mSourceData->ToParserData()->mFileName, checkTypeDef->mSource->mSourceData->ToParserData()->mFileName)) &&
 					(tempTypeDef->mProject == checkTypeDef->mProject))
 				{
-				actualTypeDef = mSystem->FilterDeletedTypeDef(checkTypeDef);
+					return mSystem->FilterDeletedTypeDef(checkTypeDef);					
-				break;
 				}
 			}
 
 			actualTypeDefItr.MoveToNextHashMatch();
 		}
+		return (BfTypeDef*)NULL;
+	};
 
-	if ((actualTypeDef == NULL) || (actualTypeDef->mTypeDeclaration == NULL))
+	if (tempTypeDef->mTypeCode == BfTypeCode_Extension)
 	{
+		BfTypeInstance* outerTypeInstance;
+
+		if (tempTypeDef->mOuterType != NULL)
+		{
+			auto outerTypeDef = _FindAcutalTypeDef(tempTypeDef->mOuterType);
+			if (outerTypeDef != NULL)
+			{
+				outerTypeInstance = (BfTypeInstance*)module->ResolveTypeDef(outerTypeDef, BfPopulateType_IdentityNoRemapAlias);
+				if ((outerTypeInstance != NULL) && (outerTypeInstance->IsIncomplete()))
+					module->PopulateType(outerTypeInstance, BfPopulateType_Full);
+			}
+		}
+
+		SetAndRestoreValue<BfTypeInstance*>  prevCurTypeInstance(module->mCurTypeInstance, outerTypeInstance);
+
 		auto autoComplete = mResolvePassData->mAutoComplete;
 		if (autoComplete->IsAutocompleteNode(tempTypeDef->mTypeDeclaration->mNameNode))
 		{
 			BfIdentifierNode* nameNode = tempTypeDef->mTypeDeclaration->mNameNode;			
-			if (tempTypeDef->mTypeCode == BfTypeCode_Extension)
-			{
 			autoComplete->AddTopLevelNamespaces(nameNode);
 			autoComplete->AddTopLevelTypes(nameNode);
 			autoComplete->mInsertStartIdx = nameNode->GetSrcStart();
@@ -3746,8 +3773,9 @@ void BfCompiler::ProcessAutocompleteTempType()
 		}
 	}
 
-		//mResolvePassData->mSourceClassifier->MarkSkipped(tempTypeDef->mTypeDeclaration);
+	BfTypeDef* actualTypeDef = _FindAcutalTypeDef(tempTypeDef);
-
+	if ((actualTypeDef == NULL) || (actualTypeDef->mTypeDeclaration == NULL))
+	{				
 		GenerateAutocompleteInfo();
 		return;
 	}

IDEHelper/Compiler/BfDefBuilder.cpp

@@ -1541,6 +1541,8 @@ void BfDefBuilder::Visit(BfTypeDeclaration* typeDeclaration)
 						
 						bool isCompatible = (isExtension == (checkTypeDef->mTypeCode == BfTypeCode_Extension)) &&
 							(checkTypeDef->mTypeCode == mCurTypeDef->mTypeCode) &&
+							(checkTypeDef->mIsDelegate == mCurTypeDef->mIsDelegate) &&
+							(checkTypeDef->mIsFunction == mCurTypeDef->mIsFunction) &&
 							(checkTypeDef->mOuterType == actualOuterTypeDef);
 						
 						if (isCompatible)
@@ -1655,6 +1657,8 @@ void BfDefBuilder::Visit(BfTypeDeclaration* typeDeclaration)
 	// Map methods into the correct index from previous revision
 	if (prevRevisionTypeDef != NULL)
 	{
+		BF_ASSERT(mCurTypeDef->mTypeCode == prevRevisionTypeDef->mTypeCode);
+
 		if ((mCurTypeDef->mFullHash == prevRevisionTypeDef->mFullHash) && (!mFullRefresh))
 		{
 			BfLogSys(bfParser->mSystem, "DefBuilder deleting typeDef with no changes %p\n", prevRevisionTypeDef);

IDEHelper/Compiler/BfMangler.cpp

@@ -1320,7 +1320,8 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfTypeI
 		}
 		else
 		{
-			auto outerType = useModule->GetOuterType(typeInstance);
+			auto unreifiedModule = useModule->mContext->mUnreifiedModule;
+			auto outerType = unreifiedModule->GetOuterType(typeInstance);
 			if (outerType != NULL)
 				Mangle(mangleContext, name, outerType, true, true);
 			else	

IDEHelper/Compiler/BfModule.cpp

@@ -5309,7 +5309,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
 				}
 			}
 
-			checkTypeInstance = GetOuterType(checkTypeInstance);
+			checkTypeInstance = mContext->mUnreifiedModule->GetOuterType(checkTypeInstance);
 		}
 	}
 
@@ -5986,7 +5986,7 @@ BfIRValue BfModule::CreateTypeData(BfType* type, Dictionary<int, int>& usedStrin
 	}
 
 	int outerTypeId = 0;
-	auto outerType = GetOuterType(typeInstance);
+	auto outerType = mContext->mUnreifiedModule->GetOuterType(typeInstance);
 	if (outerType != NULL)
 		outerTypeId = outerType->mTypeId;
 

IDEHelper/Compiler/BfModuleTypeUtils.cpp

@@ -1351,9 +1351,16 @@ int BfModule::GenerateTypeOptions(BfCustomAttributes* customAttributes, BfTypeIn
 		if (typeInstance->IsTypedPrimitive())
 		{
 			auto underlyingType = typeInstance->GetUnderlyingType();
+			if (underlyingType != NULL)						
+			{
 				String typeName = TypeToString(underlyingType);
 				_CheckTypeName(typeName);
 			}
+			else
+			{
+				// Can this only happen for functions that are being extended?
+			}
+		}
 
 		if ((!typeInstance->IsBoxed()) && (typeInstance->mTypeDef == mCompiler->mPointerTTypeDef))
 		{
@@ -1612,6 +1619,10 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy
 			}
 		}
 	}
+// 	else if (typeInstance->IsFunction())
+// 	{
+// 		underlyingType = GetPrimitiveType(BfTypeCode_NullPtr);
+// 	}
 	else if (((typeInstance->IsStruct()) || (typeInstance->IsTypedPrimitive())) &&
 		(!typeInstance->mTypeFailed))
 	{
@@ -2529,6 +2540,10 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy
 
 		BfSizedVector<BfFieldInstance*, 16> dataFieldVec;
 		
+		bool allowInstanceFields = (underlyingType == NULL);
+		if (typeInstance->IsTypedPrimitive())
+			allowInstanceFields = false;
+
 		// We've resolved all the 'var' entries, so now build the actual composite type
 		for (auto& fieldInstanceRef : typeInstance->mFieldInstances)
 		{
@@ -2618,10 +2633,12 @@ bool BfModule::DoPopulateType(BfType* resolvedTypeRef, BfPopulateType populateTy
 						if (nameRefNode == NULL)
 							nameRefNode = fieldDef->mTypeRef;
 
-						if (underlyingType != NULL)
+						if (!allowInstanceFields)
 						{
 							if (typeInstance->IsEnum())
 								Fail("Cannot declare instance members in an enum", nameRefNode, true);
+							else if (typeInstance->IsFunction())
+								Fail("Cannot declare instance members in a function", nameRefNode, true);
 							else
 								Fail("Cannot declare instance members in a typed primitive struct", nameRefNode, true);
 							TypeFailed(typeInstance);

IDEHelper/Compiler/BfStmtEvaluator.cpp

@@ -6133,7 +6133,7 @@ void BfModule::Visit(BfForEachStatement* forEachStmt)
 			{
 				AssertErrorState();
 			}
-			if (retVal)
+			if ((retVal) && (!retVal.mType->IsVar()))
 			{
 				auto i8Result = ExtractValue(nextResult, NULL, 2);
 				i8Result = LoadValue(i8Result);

IDEHelper/Compiler/BfSystem.cpp

@@ -2587,6 +2587,7 @@ void BfSystem::InjectNewRevision(BfTypeDef* typeDef)
 	typeDef->mFullHash = nextTypeDef->mFullHash;
 	typeDef->mInlineHash = nextTypeDef->mInlineHash;
 	typeDef->mNestDepth = nextTypeDef->mNestDepth;
+
 	typeDef->mOuterType = nextTypeDef->mOuterType;
 	//typeDef->mOuterType = nextTypeDef->mOuterType;
 	typeDef->mNamespace = nextTypeDef->mNamespace;
@@ -2598,6 +2599,9 @@ void BfSystem::InjectNewRevision(BfTypeDef* typeDef)
 	typeDef->mProtection = nextTypeDef->mProtection;	
 	if ((typeDef->mTypeCode != BfTypeCode_Extension) && (!typeDef->mIsCombinedPartial))
 		BF_ASSERT(nextTypeDef->mTypeCode != BfTypeCode_Extension);
+
+	BF_ASSERT(typeDef->mTypeCode == nextTypeDef->mTypeCode);
+
 	typeDef->mTypeCode = nextTypeDef->mTypeCode;
 	typeDef->mIsAlwaysInclude = nextTypeDef->mIsAlwaysInclude;
 	typeDef->mIsNoDiscard = nextTypeDef->mIsNoDiscard;
@@ -2679,6 +2683,8 @@ void BfSystem::AddToCompositePartial(BfPassInstance* passInstance, BfTypeDef* co
 
 	bool isFirst = false;
 
+	BF_ASSERT(compositeTypeDef->mFullNameEx == partialTypeDef->mFullNameEx);
+
 	auto typeDef = compositeTypeDef->mNextRevision;
 	if (typeDef == NULL)
 	{
@@ -2693,6 +2699,8 @@ void BfSystem::AddToCompositePartial(BfPassInstance* passInstance, BfTypeDef* co
 
 		typeDef->mSystem = partialTypeDef->mSystem;
 		typeDef->mTypeCode = partialTypeDef->mTypeCode;
+		typeDef->mIsFunction = partialTypeDef->mIsFunction;
+		typeDef->mIsDelegate = partialTypeDef->mIsDelegate;
 		typeDef->mNestDepth = partialTypeDef->mNestDepth;
 		typeDef->mOuterType = partialTypeDef->mOuterType;
 		typeDef->mNamespace = partialTypeDef->mNamespace;