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

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

Browse source
This commit is contained in:
Brian Fiete 2020-05-12 09:16:17 -07:00
parent c2077acc2b
commit 6c65993401
7 changed files with 121 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

82
IDEHelper/Compiler/BfCompiler.cpp
View file

@ -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);
break;
return mSystem->FilterDeletedTypeDef(checkTypeDef);
}
if ((checkTypeDef->mGenericParamDefs.size() == wantNumGenericParams) &&
(FileNameEquals(tempTypeDef->mSource->mSourceData->ToParserData()->mFileName, checkTypeDef->mSource->mSourceData->ToParserData()->mFileName)) &&
(tempTypeDef->mProject == checkTypeDef->mProject))
{
actualTypeDef = mSystem->FilterDeletedTypeDef(checkTypeDef);
break;
return mSystem->FilterDeletedTypeDef(checkTypeDef);
}
}
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;
}

4
IDEHelper/Compiler/BfDefBuilder.cpp
View file

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

3
IDEHelper/Compiler/BfMangler.cpp
View file

@ -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

4
IDEHelper/Compiler/BfModule.cpp
View file

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

19
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

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

2
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

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

8
IDEHelper/Compiler/BfSystem.cpp
View file

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