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

Handle zero-sized enums (<= 1 member)

Browse source
This commit is contained in:
Brian Fiete 2024-11-08 09:16:27 -05:00
parent 7b69509b7b
commit 14a3dd8e7d
21 changed files with 461 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

5
IDEHelper/Compiler/BfAst.cpp
View file

@ -301,6 +301,11 @@ void BfStructuralVisitor::Visit(BfTupleTypeRef* typeRef)
Visit(typeRef->ToBase());
}
void BfStructuralVisitor::Visit(BfTagTypeRef* typeRef)
{
Visit(typeRef->ToBase());
}
void BfStructuralVisitor::Visit(BfDelegateTypeRef* typeRef)
{
Visit(typeRef->ToBase());

11
IDEHelper/Compiler/BfAst.h
View file

@ -389,6 +389,7 @@ class BfVarRefTypeReference;
class BfLetTypeReference;
class BfGenericInstanceTypeRef;
class BfTupleTypeRef;
class BfTagTypeRef;
class BfDelegateTypeRef;
class BfExprModTypeRef;
class BfCommentNode;
@ -561,6 +562,7 @@ public:
virtual void Visit(BfArrayTypeRef* typeRef);
virtual void Visit(BfGenericInstanceTypeRef* typeRef);
virtual void Visit(BfTupleTypeRef* typeRef);
virtual void Visit(BfTagTypeRef* typeRef);
virtual void Visit(BfDelegateTypeRef* typeRef);
virtual void Visit(BfExprModTypeRef* declTypeRef);
virtual void Visit(BfPointerTypeRef* typeRef);
@ -2667,6 +2669,15 @@ public:
}
}; BF_AST_DECL(BfTupleTypeRef, BfElementedTypeRef);
class BfTagTypeRef : public BfTypeReference
{
public:
BF_AST_TYPE(BfTagTypeRef, BfTypeReference);
BfIdentifierNode* mTagNode;
BfIdentifierNode* mNameNode;
}; BF_AST_DECL(BfTagTypeRef, BfTypeReference);
class BfDelegateTypeRef : public BfTypeReference
{
public:

35
IDEHelper/Compiler/BfAutoComplete.cpp
View file

@ -797,12 +797,21 @@ void BfAutoComplete::AddField(BfTypeInstance* typeInst, BfFieldDef* fieldDef, Bf
{
mModule->PopulateType(typeInst);
String str;
str += mModule->TypeToString(fieldInstance->mResolvedType);
str += " ";
str += mModule->TypeToString(typeInst);
str += ".";
str += fieldDef->mName;
bool isTag = typeInst->IsEnum() && typeInst->IsOnDemand();
String str;
if (!isTag)
{
if (!fieldInstance->GetFieldDef()->IsEnumCaseEntry())
{
str += mModule->TypeToString(fieldInstance->mResolvedType);
str += " ";
}
str += mModule->TypeToString(typeInst);
str += ".";
str += fieldDef->mName;
}
if (entryAdded->mDocumentation != NULL)
{
str += "\x04";
@ -813,7 +822,9 @@ void BfAutoComplete::AddField(BfTypeInstance* typeInst, BfFieldDef* fieldDef, Bf
str += "\x05";
documentation->GetDocString(str);
}
entryAdded->mDocumentation = mAlloc.AllocString(str);
if (!str.IsEmpty())
entryAdded->mDocumentation = mAlloc.AllocString(str);
}
if ((mIsGetDefinition) && (mDefType == NULL))
@ -1270,7 +1281,11 @@ void BfAutoComplete::AddEnumTypeMembers(BfTypeInstance* typeInst, const StringIm
AutoCompleteEntry entry(hasPayload ? "payloadEnum" : "value", fieldDef->mName);
if (auto entryAdded = AddEntry(entry, filter))
{
if (CheckDocumentation(entryAdded, fieldDef->GetFieldDeclaration()->mDocumentation))
auto fieldDecl = fieldDef->GetFieldDeclaration();
if (fieldDecl == NULL)
continue;
if (CheckDocumentation(entryAdded, fieldDecl->mDocumentation))
{
}
@ -1278,8 +1293,8 @@ void BfAutoComplete::AddEnumTypeMembers(BfTypeInstance* typeInst, const StringIm
{
mDefType = typeInst->mTypeDef;
mDefField = fieldDef;
if (fieldDef->mFieldDeclaration != NULL)
SetDefinitionLocation(fieldDef->GetFieldDeclaration()->mNameNode);
if (fieldDecl != NULL)
SetDefinitionLocation(fieldDecl->mNameNode);
}
}
}

4
IDEHelper/Compiler/BfAutoComplete.h
View file

@ -137,6 +137,8 @@ public:
BfTypeInstance* mTypeInstance;
BfTypeVector mGenericArguments;
BfMethodInstance* mCurMethodInstance;
bool mIsMatch;
int mArgMatchCount;
MethodMatchEntry()
{
@ -144,6 +146,8 @@ public:
mPayloadEnumField = NULL;
mTypeInstance = NULL;
mCurMethodInstance = NULL;
mIsMatch = false;
mArgMatchCount = false;
}
};

4
IDEHelper/Compiler/BfCompiler.cpp
View file

@ -8608,7 +8608,9 @@ void BfCompiler::GenerateAutocompleteInfo()
}
}
autoCompleteResultString += "invoke\t" + methodText + "\n";
autoCompleteResultString += "invoke\t" + methodText;
autoCompleteResultString += StrFormat("\t%d", methodEntry.mArgMatchCount);
autoCompleteResultString += "\n";
idx++;
}

8
IDEHelper/Compiler/BfElementVisitor.cpp
View file

@ -447,6 +447,14 @@ void BfElementVisitor::Visit(BfTupleTypeRef* typeRef)
VisitChild(typeRef->mCloseParen);
}
void BfElementVisitor::Visit(BfTagTypeRef* typeRef)
{
Visit(typeRef->ToBase());
VisitChild(typeRef->mTagNode);
VisitChild(typeRef->mNameNode);
}
void BfElementVisitor::Visit(BfExprModTypeRef* typeRef)
{
Visit(typeRef->ToBase());

1
IDEHelper/Compiler/BfElementVisitor.h
View file

@ -64,6 +64,7 @@ public:
virtual void Visit(BfArrayTypeRef* typeRef);
virtual void Visit(BfGenericInstanceTypeRef* typeRef);
virtual void Visit(BfTupleTypeRef* typeRef);
virtual void Visit(BfTagTypeRef* typeRef);
virtual void Visit(BfExprModTypeRef* typeRef);
virtual void Visit(BfDelegateTypeRef* typeRef);
virtual void Visit(BfPointerTypeRef* typeRef);

14
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -1680,7 +1680,7 @@ bool BfMethodMatcher::CheckMethod(BfTypeInstance* targetTypeInstance, BfTypeInst
BP_ZONE("BfMethodMatcher::CheckMethod");
BackupMatchKind curMatchKind = BackupMatchKind_None;
bool hadMatch = false;
bool hadMatch = false;
// Never consider overrides - they only get found at original method declaration
// mBypassVirtual gets set when we are doing an explicit "base" call, or when we are a struct --
@ -2599,12 +2599,16 @@ NoMatch:
}
Done:
if ((autoComplete != NULL) && (autoComplete->mIsCapturingMethodMatchInfo) && (genericArgumentsSubstitute != NULL))
if ((autoComplete != NULL) && (autoComplete->mIsCapturingMethodMatchInfo))
{
auto methodMatchInfo = autoComplete->mMethodMatchInfo;
if (!methodMatchInfo->mInstanceList.IsEmpty())
{
methodMatchInfo->mInstanceList[methodMatchInfo->mInstanceList.size() - 1].mGenericArguments = *genericArgumentsSubstitute;
{
auto& matchInstance = methodMatchInfo->mInstanceList[methodMatchInfo->mInstanceList.size() - 1];
matchInstance.mArgMatchCount = argMatchCount;
matchInstance.mIsMatch = hadMatch;
if (genericArgumentsSubstitute != NULL)
matchInstance.mGenericArguments = *genericArgumentsSubstitute;
}
}
@ -5249,6 +5253,8 @@ BfTypedValue BfExprEvaluator::LoadField(BfAstNode* targetSrc, BfTypedValue targe
BF_ASSERT(fieldInstance->mConstIdx != -1);
auto foreignConst = typeInstance->mConstHolder->GetConstantById(fieldInstance->mConstIdx);
if (resolvedFieldType->IsValuelessType())
return BfTypedValue(BfIRValue::sValueless, resolvedFieldType);
auto retVal = mModule->ConstantToCurrent(foreignConst, typeInstance->mConstHolder, resolvedFieldType);
return BfTypedValue(retVal, resolvedFieldType);
}

9
IDEHelper/Compiler/BfIRBuilder.cpp
View file

@ -928,6 +928,10 @@ BfIRValue BfIRConstHolder::CreateConst(BfConstant* fromConst, BfIRConstHolder* f
{
return CreateConstArrayZero(fromConst->mInt32);
}
else if (fromConst->mTypeCode == BfTypeCode_None)
{
return CreateConst(fromConst->mTypeCode, 0);
}
else if ((IsInt(fromConst->mTypeCode)) || (fromConst->mTypeCode == BfTypeCode_Boolean) || (fromConst->mTypeCode == BfTypeCode_StringId))
{
return CreateConst(fromConst->mTypeCode, fromConst->mUInt64);
@ -975,7 +979,7 @@ BfIRValue BfIRConstHolder::CreateConst(BfConstant* fromConst, BfIRConstHolder* f
box->mTarget = copiedTarget.mId;
box->mToType = fromBox->mToType;
copiedConst = (BfConstant*)box;
}
}
else
{
BF_FATAL("not handled");
@ -3283,7 +3287,8 @@ void BfIRBuilder::CreateDbgTypeDefinition(BfType* type)
if (fieldInstance->mConstIdx != -1)
{
constant = typeInstance->mConstHolder->GetConstantById(fieldInstance->mConstIdx);
staticValue = mModule->ConstantToCurrent(constant, typeInstance->mConstHolder, resolvedFieldType);
if (!resolvedFieldType->IsValuelessType())
staticValue = mModule->ConstantToCurrent(constant, typeInstance->mConstHolder, resolvedFieldType);
}
if (fieldInstance->mResolvedType->IsComposite())

9
IDEHelper/Compiler/BfModule.cpp
View file

@ -21841,10 +21841,10 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
mBfIRBuilder->SaveDebugLocation();
mBfIRBuilder->ClearDebugLocation();
BfIRValue fromBool;
if (!mCurTypeInstance->IsTypedPrimitive())
if ((!mCurTypeInstance->IsTypedPrimitive()) || (mCurTypeInstance->IsValuelessType()))
{
fromBool = GetDefaultValue(methodInstance->mReturnType);
}
}
else
{
auto andResult = mBfIRBuilder->CreateAnd(mCurMethodState->mLocals[0]->mValue, mCurMethodState->mLocals[1]->mValue);
@ -21872,7 +21872,10 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
mBfIRBuilder->ClearDebugLocation();
BfIRValue fromBool;
mBfIRBuilder->RestoreDebugLocation();
ret = mBfIRBuilder->CreateRet(GetThis().mValue);
if (!mCurTypeInstance->IsValuelessType())
ret = mBfIRBuilder->CreateRet(GetThis().mValue);
else
mBfIRBuilder->CreateRetVoid();
//ExtendLocalLifetimes(0);
EmitLifetimeEnds(&mCurMethodState->mHeadScope);

24
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

@ -3600,7 +3600,9 @@ void BfModule::DoPopulateType_FinishEnum(BfTypeInstance* typeInstance, bool unde
{
BfTypeCode typeCode;
if ((min >= -0x80) && (max <= 0x7F))
if ((min == 0) && (max == 0))
typeCode = BfTypeCode_None;
else if ((min >= -0x80) && (max <= 0x7F))
typeCode = BfTypeCode_Int8;
else if ((min >= 0) && (max <= 0xFF))
typeCode = BfTypeCode_UInt8;
@ -12232,6 +12234,19 @@ BfType* BfModule::ResolveTypeRef_Ref(BfTypeReference* typeRef, BfPopulateType po
return ResolveTypeResult(typeRef, tupleType, populateType, resolveFlags);
}
else if (auto tagTypeRef = BfNodeDynCast<BfTagTypeRef>(typeRef))
{
auto baseType = (BfTypeInstance*)ResolveTypeDef(mContext->mCompiler->mEnumTypeDef, BfPopulateType_Identity);
BfTagType* tagType = new BfTagType();
tagType->Init(baseType->mTypeDef->mProject, baseType, tagTypeRef->mNameNode->ToString());
resolvedEntry->mValue = tagType;
BF_ASSERT(BfResolvedTypeSet::Hash(tagType, &lookupCtx) == resolvedEntry->mHashCode);
populateModule->InitType(tagType, populateType);
return ResolveTypeResult(typeRef, tagType, populateType, resolveFlags);
}
else if (auto nullableTypeRef = BfNodeDynCast<BfNullableTypeRef>(typeRef))
{
BfTypeReference* elementTypeRef = nullableTypeRef->mElementType;
@ -15781,6 +15796,13 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF
str += ")";
return;
}
else if ((resolvedType->IsOnDemand()) && (resolvedType->IsEnum()))
{
auto typeInst = resolvedType->ToTypeInstance();
str += "tag ";
str += typeInst->mTypeDef->mFields[0]->mName;
return;
}
else if (resolvedType->IsDelegateFromTypeRef() || resolvedType->IsFunctionFromTypeRef())
{
SetAndRestoreValue<BfTypeInstance*> prevTypeInstance(mCurTypeInstance);

9
IDEHelper/Compiler/BfPrinter.cpp
View file

@ -1674,6 +1674,15 @@ void BfPrinter::Visit(BfTupleTypeRef* typeRef)
VisitChild(typeRef->mCloseParen);
}
void BfPrinter::Visit(BfTagTypeRef* typeRef)
{
Visit((BfAstNode*)typeRef);
VisitChild(typeRef->mTagNode);
ExpectSpace();
VisitChild(typeRef->mNameNode);
}
void BfPrinter::Visit(BfDelegateTypeRef* typeRef)
{
Visit((BfAstNode*)typeRef);

1
IDEHelper/Compiler/BfPrinter.h
View file

@ -167,6 +167,7 @@ public:
virtual void Visit(BfArrayTypeRef* typeRef) override;
virtual void Visit(BfGenericInstanceTypeRef* typeRef) override;
virtual void Visit(BfTupleTypeRef * typeRef) override;
virtual void Visit(BfTagTypeRef* typeRef) override;
virtual void Visit(BfDelegateTypeRef* typeRef) override;
virtual void Visit(BfPointerTypeRef* typeRef) override;
virtual void Visit(BfNullableTypeRef* typeRef) override;

34
IDEHelper/Compiler/BfReducer.cpp
View file

@ -937,7 +937,7 @@ bool BfReducer::IsTypeReference(BfAstNode* checkNode, BfToken successToken, int
// Ignore
}
else if ((checkNode->IsA<BfIdentifierNode>()) || (checkNode->IsA<BfMemberReferenceExpression>()))
{
{
// Identifier is always allowed in tuple (parenDepth == 0), because it's potentially the field name
// (successToken == BfToken_RParen) infers we are already checking inside parentheses, such as
// when we see a potential cast expression
@ -954,8 +954,15 @@ bool BfReducer::IsTypeReference(BfAstNode* checkNode, BfToken successToken, int
hadUnexpectedIdentifier = true;
}
hadIdentifier = true;
identifierExpected = false;
// if (checkNode->Equals("tag"))
// {
// // Keep looking for tag name
// }
// else
{
hadIdentifier = true;
identifierExpected = false;
}
}
else if (checkNode->IsA<BfBlock>())
{
@ -5195,6 +5202,19 @@ BfTypeReference* BfReducer::DoCreateTypeRef(BfAstNode* firstNode, CreateTypeRefF
BfTypeReference* typeRef = BfNodeDynCast<BfTypeReference>(firstNode);
if (typeRef == NULL)
{
// if (identifierNode->Equals("tag"))
// {
// auto rightIdentifer = ExpectIdentifierAfter(identifierNode);
// if (rightIdentifer != NULL)
// {
// auto tagTypeRef = mAlloc->Alloc<BfTagTypeRef>();
// ReplaceNode(identifierNode, tagTypeRef);
// tagTypeRef->mTagNode = identifierNode;
// MEMBER_SET(tagTypeRef, mNameNode, rightIdentifer);
// return tagTypeRef;
// }
// }
typeRef = DoCreateNamedTypeRef(identifierNode);
}
@ -5250,7 +5270,7 @@ BfTypeReference* BfReducer::DoCreateTypeRef(BfAstNode* firstNode, CreateTypeRefF
{
auto rightIdentifer = ExpectIdentifierAfter(qualifiedTypeRef);
if (rightIdentifer == NULL)
return qualifiedTypeRef;
return qualifiedTypeRef;
auto namedTypeRef = mAlloc->Alloc<BfNamedTypeReference>();
namedTypeRef->mNameNode = rightIdentifer;
@ -7346,7 +7366,7 @@ BfAstNode* BfReducer::ReadTypeMember(BfAstNode* node, bool declStarted, int dept
if (openToken == NULL)
return indexerDeclaration;
MEMBER_SET(indexerDeclaration, mOpenBracket, openToken);
auto endToken = ParseMethodParams(indexerDeclaration, &params, &commas, BfToken_RBracket, true);
auto endToken = ParseMethodParams(indexerDeclaration, &params, &commas, BfToken_RBracket, false);
if (endToken == NULL)
return indexerDeclaration;
MEMBER_SET(indexerDeclaration, mCloseBracket, endToken);
@ -7780,7 +7800,7 @@ BfLambdaBindExpression* BfReducer::CreateLambdaBindExpression(BfAstNode* allocNo
if (auto tokenNode = BfNodeDynCast<BfTokenNode>(nextNode))
isRParen = tokenNode->GetToken() == BfToken_RParen;
if (!isRParen)
{
{
auto nameIdentifier = ExpectIdentifierAfter(lambdaBindExpr, "parameter name");
if (nameIdentifier == NULL)
return lambdaBindExpr;
@ -10028,7 +10048,7 @@ bool BfReducer::ParseMethod(BfMethodDeclaration* methodDeclaration, SizedArrayIm
}
}
methodDeclaration->mCloseParen = ParseMethodParams(methodDeclaration, params, commas, BfToken_RParen, true);
methodDeclaration->mCloseParen = ParseMethodParams(methodDeclaration, params, commas, BfToken_RParen, false);
// RParen
if (methodDeclaration->mCloseParen == NULL)

101
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -2987,6 +2987,79 @@ void BfTupleType::Finish()
//////////////////////////////////////////////////////////////////////////
BfTagType::BfTagType()
{
mCreatedTypeDef = false;
mSource = NULL;
mTypeDef = NULL;
}
BfTagType::~BfTagType()
{
mMethodInstanceGroups.Clear();
if (mCreatedTypeDef)
{
delete mTypeDef;
mTypeDef = NULL;
}
delete mSource;
}
void BfTagType::Init(BfProject* bfProject, BfTypeInstance* valueTypeInstance, const StringImpl& name)
{
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_Enum;
mCreatedTypeDef = true;
auto field = BfDefBuilder::AddField(mTypeDef, NULL, name);
field->mIsStatic = true;
field->mIsConst = true;
}
void BfTagType::Dispose()
{
if (mCreatedTypeDef)
{
delete mTypeDef;
mTypeDef = NULL;
mCreatedTypeDef = false;
}
BfTypeInstance::Dispose();
}
void BfTagType::Finish()
{
BF_ASSERT(!mTypeFailed);
auto bfSystem = mTypeDef->mSystem;
mSource = new BfSource(bfSystem);
mTypeDef->mSource = mSource;
mTypeDef->mSource->mRefCount++;
BfDefBuilder bfDefBuilder(bfSystem);
bfDefBuilder.mCurTypeDef = mTypeDef;
bfDefBuilder.mCurDeclaringTypeDef = mTypeDef;
bfDefBuilder.FinishTypeDef(true);
}
//////////////////////////////////////////////////////////////////////////
BfBoxedType::~BfBoxedType()
{
//if ((mTypeDef != NULL) && (mTypeDef->mEmitParent != NULL))
@ -3132,6 +3205,7 @@ BfResolvedTypeSet::~BfResolvedTypeSet()
#define HASH_CONSTEXPR 12
#define HASH_GLOBAL 13
#define HASH_DOTDOTDOT 14
#define HASH_TAG 15
BfVariant BfResolvedTypeSet::EvaluateToVariant(LookupContext* ctx, BfExpression* expr, BfType*& outType)
{
@ -3234,6 +3308,13 @@ int BfResolvedTypeSet::DoHash(BfType* type, LookupContext* ctx, bool allowRef, i
return hashVal;
}
else if ((type->IsEnum()) && (type->IsOnDemand()))
{
BfTypeInstance* typeInstance = type->ToTypeInstance();
auto fieldName = typeInstance->mTypeDef->mFields[0]->mName;
int nameHash = (int)Hash64(fieldName.c_str(), (int)fieldName.length());
return nameHash ^ HASH_TAG;
}
else if (type->IsTypeInstance())
{
BfTypeInstance* typeInst = (BfTypeInstance*)type;
@ -4156,6 +4237,17 @@ int BfResolvedTypeSet::DoHash(BfTypeReference* typeRef, LookupContext* ctx, BfHa
ctx->mFailed = true;
return 0;
}
else if (auto tagTypeRef = BfNodeDynCastExact<BfTagTypeRef>(typeRef))
{
int nameHash = 0;
if (tagTypeRef->mNameNode != NULL)
{
auto fieldName = tagTypeRef->mNameNode;
const char* nameStr = fieldName->GetSourceData()->mSrc + fieldName->GetSrcStart();
nameHash = (int)Hash64(nameStr, fieldName->GetSrcLength());
}
return nameHash ^ HASH_TAG;
}
else
{
BF_FATAL("Not handled");
@ -4839,6 +4931,15 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
return true;
}
else if ((lhs->IsEnum()) && (lhs->IsOnDemand()))
{
BfTypeInstance* typeInstance = lhs->ToTypeInstance();
auto fieldName = typeInstance->mTypeDef->mFields[0]->mName;
auto tagTypeRef = BfNodeDynCastExact<BfTagTypeRef>(rhs);
if (tagTypeRef == NULL)
return false;
return tagTypeRef->mNameNode->Equals(fieldName);
}
else if (lhs->IsTypeInstance())
{
BfTypeInstance* lhsInst = (BfTypeInstance*) lhs;

18
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -2401,6 +2401,24 @@ public:
virtual int GetGenericDepth() override { return mGenericDepth; }
};
class BfTagType : public BfTypeInstance
{
public:
bool mCreatedTypeDef;
String mNameAdd;
BfSource* mSource;
public:
BfTagType();
~BfTagType();
void Init(BfProject* bfProject, BfTypeInstance* valueTypeInstance, const StringImpl& name);
virtual void Dispose() override;
void Finish();
virtual bool IsOnDemand() override { return true; }
};
class BfConcreteInterfaceType : public BfType
{
public:

11
IDEHelper/Compiler/BfSourceClassifier.cpp
View file

@ -329,6 +329,17 @@ void BfSourceClassifier::Visit(BfNamedTypeReference* typeRef)
}
}
void BfSourceClassifier::Visit(BfTagTypeRef* typeRef)
{
Visit((BfAstNode*)typeRef);
VisitChild(typeRef->mTagNode);
SetElementType(typeRef->mTagNode, BfSourceElementType_Keyword);
VisitChild(typeRef->mNameNode);
SetElementType(typeRef->mNameNode, BfSourceElementType_Type);
}
void BfSourceClassifier::Visit(BfQualifiedTypeReference* qualifiedType)
{
Visit((BfAstNode*)qualifiedType);

1
IDEHelper/Compiler/BfSourceClassifier.h
View file

@ -113,6 +113,7 @@ public:
virtual void Visit(BfArrayTypeRef* arrayType) override;
virtual void Visit(BfPointerTypeRef* pointerType) override;
virtual void Visit(BfNamedTypeReference* typeRef) override;
virtual void Visit(BfTagTypeRef* typeRef) override;
virtual void Visit(BfGenericInstanceTypeRef* typeRef) override;
virtual void Visit(BfLocalMethodDeclaration * methodDecl) override;
virtual void Visit(BfLiteralExpression* literalExpr) override;

6
IDEHelper/Compiler/BfSystem.cpp
View file

@ -427,6 +427,12 @@ void BfParameterDef::SetName(BfAstNode* nameNode)
//////////////////////////////////////////////////////////////////////////
bool BfFieldDef::IsEnumCaseEntry()
{
return ((mFieldDeclaration != NULL) && (BfNodeIsA<BfEnumEntryDeclaration>(mFieldDeclaration))) ||
((mFieldDeclaration == NULL) && (mIsConst) && (mDeclaringType->mTypeCode == BfTypeCode_Enum));
}
bool BfPropertyDef::IsVirtual()
{
if (((BfPropertyDeclaration*)mFieldDeclaration)->mVirtualSpecifier)

5
IDEHelper/Compiler/BfSystem.h
View file

@ -655,10 +655,7 @@ public:
return (mName[0] >= '0') && (mName[0] <= '9');
}
bool IsEnumCaseEntry()
{
return (mFieldDeclaration != NULL) && (BfNodeIsA<BfEnumEntryDeclaration>(mFieldDeclaration));
}
bool IsEnumCaseEntry();
bool IsNonConstStatic()
{