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

Circular dependency checking between generic constraints

Browse source
This commit is contained in:
Brian Fiete 2022-04-25 17:53:54 -07:00
parent e307448363
commit 2bbe66cecc
7 changed files with 108 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

19
IDE/Tests/CompileFail001/src/Generics.bf
View file

@ -109,5 +109,24 @@ namespace IDETest
TestPreGen<List<int>>();
Method7<int>(); //FAIL The type 'int' must be a reference type in order to use it as parameter 'comptype(typeof(T))' for 'IDETest.Generics.Method7<int>()'
}
public static void CircDepMethod<T, T2>() where T : T2 where T2 : T //FAIL
{
}
class CircDep<T> where T : T //FAIL
{
}
}
}
namespace System.Collections
{
extension List<T> //FAIL
where T : T
{
}
}

7
IDEHelper/Compiler/BfModule.cpp
View file

@ -22953,6 +22953,13 @@ void BfModule::DoMethodDeclaration(BfMethodDeclaration* methodDeclaration, bool
for (auto typeRef : deferredResolveTypes)
auto constraintType = ResolveTypeRef(typeRef, BfPopulateType_Declaration, BfResolveTypeRefFlag_None);
if (methodInstance->mMethodInfoEx != NULL)
{
ValidateGenericParams(BfGenericParamKind_Method,
Span<BfGenericParamInstance*>((BfGenericParamInstance**)methodInstance->mMethodInfoEx->mGenericParams.mVals,
methodInstance->mMethodInfoEx->mGenericParams.mSize));
}
for (auto genericParam : methodInstance->mMethodInfoEx->mGenericParams)
AddDependency(genericParam, mCurTypeInstance);
}

2
IDEHelper/Compiler/BfModule.h
View file

@ -16,6 +16,7 @@
#include "BeefySysLib/util/Hash.h"
#include "BeefySysLib/util/HashSet.h"
#include "BeefySysLib/util/SizedArray.h"
#include "BeefySysLib/Span.h"
#include "BfSourceClassifier.h"
#include "BfAst.h"
#include "BfSystem.h"
@ -1756,6 +1757,7 @@ public:
BfType* ResolveGenericMethodTypeRef(BfTypeReference* typeRef, BfMethodInstance* methodInstance, BfGenericParamInstance* genericParamInstance, BfTypeVector* methodGenericArgsOverride);
bool AreConstraintsSubset(BfGenericParamInstance* checkInner, BfGenericParamInstance* checkOuter);
bool CheckConstraintState(BfAstNode* refNode);
void ValidateGenericParams(BfGenericParamKind genericParamKind, Span<BfGenericParamInstance*> genericParams);
bool ShouldAllowMultipleDefinitions(BfTypeInstance* typeInst, BfTypeDef* firstDeclaringTypeDef, BfTypeDef* secondDeclaringTypeDef);
void CheckInjectNewRevision(BfTypeInstance* typeInstance);
void InitType(BfType* resolvedTypeRef, BfPopulateType populateType);

60
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

@ -110,6 +110,10 @@ BfGenericExtensionEntry* BfModule::BuildGenericExtensionInfo(BfTypeInstance* gen
for (auto genericParam : genericExEntry->mGenericParams)
AddDependency(genericParam, mCurTypeInstance);
ValidateGenericParams(BfGenericParamKind_Type,
Span<BfGenericParamInstance*>((BfGenericParamInstance**)genericExEntry->mGenericParams.mVals,
genericExEntry->mGenericParams.mSize));
return genericExEntry;
}
@ -327,12 +331,68 @@ bool BfModule::FinishGenericParams(BfType* resolvedTypeRef)
for (auto typeRef : deferredResolveTypes)
auto constraintType = ResolveTypeRef(typeRef, BfPopulateType_Declaration, BfResolveTypeRefFlag_None);
ValidateGenericParams(BfGenericParamKind_Type,
Span<BfGenericParamInstance*>((BfGenericParamInstance**)genericTypeInst->mGenericTypeInfo->mGenericParams.mVals,
genericTypeInst->mGenericTypeInfo->mGenericParams.mSize));
for (auto genericParam : genericTypeInst->mGenericTypeInfo->mGenericParams)
AddDependency(genericParam, mCurTypeInstance);
return true;
}
void BfModule::ValidateGenericParams(BfGenericParamKind genericParamKind, Span<BfGenericParamInstance*> genericParams)
{
std::function<void(BfType*, Array<BfGenericParamType*>&)> _CheckType = [&](BfType* type, Array<BfGenericParamType*>& foundParams)
{
if (type == NULL)
return;
if (!type->IsGenericParam())
return;
auto genericParamType = (BfGenericParamType*)type;
if (genericParamType->mGenericParamKind != genericParamKind)
return;
auto genericParam = genericParams[genericParamType->mGenericParamIdx];
if (genericParam->mTypeConstraint == NULL)
return;
if (foundParams.Contains(genericParamType))
{
String error = "Circular constraint dependency between ";
for (int i = 0; i < foundParams.mSize; i++)
{
auto foundParam = foundParams[i];
if (i > 0)
error += " and ";
error += TypeToString(foundParam, BfTypeNameFlag_ResolveGenericParamNames);
// Remove errored type constraint
genericParams[foundParam->mGenericParamIdx]->mTypeConstraint = NULL;
}
if (foundParams.mSize == 1)
error += " and itself";
Fail(error, genericParams[genericParamType->mGenericParamIdx]->GetRefNode());
return;
}
foundParams.Add(genericParamType);
_CheckType(genericParam->mTypeConstraint, foundParams);
foundParams.pop_back();
};
for (auto genericParam : genericParams)
{
if (genericParam->mTypeConstraint != NULL)
{
Array<BfGenericParamType*> foundParams;
_CheckType(genericParam->mTypeConstraint, foundParams);
}
}
}
bool BfModule::ValidateGenericConstraints(BfAstNode* typeRef, BfTypeInstance* genericTypeInst, bool ignoreErrors)
{
if ((mCurTypeInstance != NULL) && (mCurTypeInstance->IsTypeAlias()) && (mCurTypeInstance->IsGenericTypeInstance()))

15
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -1204,6 +1204,7 @@ public:
virtual BfGenericParamDef* GetGenericParamDef() = 0;
virtual BfExternalConstraintDef* GetExternConstraintDef() = 0;
virtual String GetName() = 0;
virtual BfAstNode* GetRefNode() = NULL;
bool IsEnum();
};
@ -1255,6 +1256,13 @@ public:
return mTypeDef->mGenericParamDefs[mGenericIdx]->mName;
return mTypeDef->mExternalConstraints[mGenericIdx - (int)mTypeDef->mGenericParamDefs.size()].mTypeRef->ToString();
}
virtual BfAstNode* GetRefNode() override
{
if (mGenericIdx < (int)mTypeDef->mGenericParamDefs.size())
return mTypeDef->mGenericParamDefs[mGenericIdx]->mNameNodes[0];
return mTypeDef->mExternalConstraints[mGenericIdx - (int)mTypeDef->mGenericParamDefs.size()].mTypeRef;
}
};
class BfGenericMethodParamInstance : public BfGenericParamInstance
@ -1305,6 +1313,13 @@ public:
return mMethodDef->mGenericParams[mGenericIdx]->mName;
return mMethodDef->mExternalConstraints[mGenericIdx - (int)mMethodDef->mGenericParams.size()].mTypeRef->ToString();
}
virtual BfAstNode* GetRefNode() override
{
if (mGenericIdx < (int)mMethodDef->mGenericParams.size())
return mMethodDef->mGenericParams[mGenericIdx]->mNameNodes[0];
return mMethodDef->mExternalConstraints[mGenericIdx - (int)mMethodDef->mGenericParams.size()].mTypeRef;
}
};
#define BF_VALCOMP(val) if (val != 0) return val

4
IDEHelper/HotScanner.cpp
View file

@ -297,7 +297,7 @@ void DbgHotScanner::ScanRoot(addr_target rootPtr, int memKind)
continue;
int expectedStartPage = (rootIdx * PageHeap::PageMap::LEAF_LENGTH) + leafIdx;
Span span;
TCFake::Span span;
mDebugger->ReadMemory(spanAddr, sizeof(span), &span);
ScanSpan(&span, expectedStartPage, memKind);
}
@ -326,7 +326,7 @@ void DbgHotScanner::ScanRoot(addr_target rootPtr, int memKind)
continue;
int expectedStartPage = ((pageIdx1 * PageHeap::PageMap::INTERIOR_LENGTH) + pageIdx2) * PageHeap::PageMap::LEAF_LENGTH + pageIdx3;
Span span;
TCFake::Span span;
mDebugger->ReadMemory(spanAddr, sizeof(span), &span);
ScanSpan(&span, expectedStartPage, memKind);
}