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

Fixed some unknown-sized array resolution issues

Browse source
This commit is contained in:
Brian Fiete 2020-12-24 10:29:09 -08:00
parent 0952f3f278
commit f6877d98f0
6 changed files with 38 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

10
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -508,10 +508,10 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
return InferGenericArgument(methodInstance, argPointerType->mElementType, wantPointerType->mElementType, BfIRValue()); return InferGenericArgument(methodInstance, argPointerType->mElementType, wantPointerType->mElementType, BfIRValue());
} }
if (wantType->IsUnknownSizedArray()) if (wantType->IsUnknownSizedArrayType())
{ {
auto wantArrayType = (BfUnknownSizedArrayType*)wantType; auto wantArrayType = (BfUnknownSizedArrayType*)wantType;
if (argType->IsUnknownSizedArray()) if (argType->IsUnknownSizedArrayType())
{ {
auto argArrayType = (BfUnknownSizedArrayType*)argType; auto argArrayType = (BfUnknownSizedArrayType*)argType;
InferGenericArgument(methodInstance, argArrayType->mElementCountSource, wantArrayType->mElementCountSource, BfIRValue()); InferGenericArgument(methodInstance, argArrayType->mElementCountSource, wantArrayType->mElementCountSource, BfIRValue());
@ -5002,7 +5002,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, BfMethodInstance*
{ {
if (methodInstance->mReturnType->IsInstanceOf(mModule->mCompiler->mSpanTypeDef)) if (methodInstance->mReturnType->IsInstanceOf(mModule->mCompiler->mSpanTypeDef))
{ {
if (mExpectingType->IsSizedArray()) if ((mExpectingType != NULL) && (mExpectingType->IsSizedArray()))
{ {
return BfTypedValue(mModule->mBfIRBuilder->GetUndefConstValue(mModule->mBfIRBuilder->MapType(mExpectingType)), mExpectingType); return BfTypedValue(mModule->mBfIRBuilder->GetUndefConstValue(mModule->mBfIRBuilder->MapType(mExpectingType)), mExpectingType);
} }
@ -18478,8 +18478,8 @@ void BfExprEvaluator::Visit(BfIndexerExpression* indexerExpr)
mModule->MakeAddressable(target); mModule->MakeAddressable(target);
mModule->PopulateType(underlyingType); mModule->PopulateType(underlyingType);
if ((sizedArrayType->IsUnknownSizedArray()) || (isUndefIndex)) if ((sizedArrayType->IsUndefSizedArray()) || (isUndefIndex))
{ {
mResult = mModule->GetDefaultTypedValue(underlyingType, false, BfDefaultValueKind_Addr); mResult = mModule->GetDefaultTypedValue(underlyingType, false, BfDefaultValueKind_Addr);
} }
else if (sizedArrayType->IsValuelessType()) else if (sizedArrayType->IsValuelessType())

2
IDEHelper/Compiler/BfMangler.cpp
View file

@ -1668,7 +1668,7 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType*
} }
else if (type->IsSizedArray()) else if (type->IsSizedArray())
{ {
if (type->IsUnknownSizedArray()) if (type->IsUnknownSizedArrayType())
{ {
auto arrType = (BfUnknownSizedArrayType*)type; auto arrType = (BfUnknownSizedArrayType*)type;
name += StrFormat("arr_$", arrType->mSize); name += StrFormat("arr_$", arrType->mSize);

33
IDEHelper/Compiler/BfModule.cpp
View file

@ -3774,7 +3774,7 @@ void BfModule::ResolveConstField(BfTypeInstance* typeInstance, BfFieldInstance*
auto prevInsertBlock = mBfIRBuilder->GetInsertBlock(); auto prevInsertBlock = mBfIRBuilder->GetInsertBlock();
if (fieldType->IsVar()) if ((fieldType->IsVar()) || (fieldType->IsUndefSizedArray()))
{ {
auto initValue = GetFieldInitializerValue(fieldInstance, fieldDef->mInitializer, fieldDef, fieldType); auto initValue = GetFieldInitializerValue(fieldInstance, fieldDef->mInitializer, fieldDef, fieldType);
if (!initValue) if (!initValue)
@ -3784,7 +3784,15 @@ void BfModule::ResolveConstField(BfTypeInstance* typeInstance, BfFieldInstance*
} }
if (fieldInstance != NULL) if (fieldInstance != NULL)
{ {
fieldInstance->mResolvedType = initValue.mType; if (fieldType->IsUndefSizedArray())
{
if ((initValue.mType->IsSizedArray()) && (initValue.mType->GetUnderlyingType() == fieldType->GetUnderlyingType()))
{
fieldInstance->mResolvedType = initValue.mType;
}
}
else
fieldInstance->mResolvedType = initValue.mType;
} }
constValue = initValue.mValue; constValue = initValue.mValue;
} }
@ -3843,7 +3851,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
if (!fieldInstance->mIsInferredType) if (!fieldInstance->mIsInferredType)
return fieldType; return fieldType;
if (!fieldType->IsVar()) if ((!fieldType->IsVar()) && (!fieldType->IsUndefSizedArray()))
return fieldType; return fieldType;
SetAndRestoreValue<BfTypeInstance*> prevTypeInstance(mCurTypeInstance, typeInstance); SetAndRestoreValue<BfTypeInstance*> prevTypeInstance(mCurTypeInstance, typeInstance);
@ -3856,7 +3864,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
if ((!field->mIsStatic) && (typeDef->mIsStatic)) if ((!field->mIsStatic) && (typeDef->mIsStatic))
{ {
AssertErrorState(); AssertErrorState();
return GetPrimitiveType(BfTypeCode_Var); return fieldType;
} }
bool hadInferenceCycle = false; bool hadInferenceCycle = false;
@ -3875,7 +3883,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
fieldModule->Fail(StrFormat("Field '%s.%s' creates a type inference cycle", TypeToString(fieldOwner).c_str(), fieldDef->mName.c_str()), fieldDef->mTypeRef, true); fieldModule->Fail(StrFormat("Field '%s.%s' creates a type inference cycle", TypeToString(fieldOwner).c_str(), fieldDef->mName.c_str()), fieldDef->mTypeRef, true);
} }
return GetPrimitiveType(BfTypeCode_Var); return fieldType;
} }
} }
mContext->mFieldResolveReentrys.push_back(fieldInstance); mContext->mFieldResolveReentrys.push_back(fieldInstance);
@ -3888,7 +3896,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
{ {
if ((field->mTypeRef->IsA<BfVarTypeReference>()) || (field->mTypeRef->IsA<BfLetTypeReference>())) if ((field->mTypeRef->IsA<BfVarTypeReference>()) || (field->mTypeRef->IsA<BfLetTypeReference>()))
Fail("Implicitly-typed fields must be initialized", field->GetRefNode()); Fail("Implicitly-typed fields must be initialized", field->GetRefNode());
return GetPrimitiveType(BfTypeCode_Var); return fieldType;
} }
BfType* resolvedType = NULL; BfType* resolvedType = NULL;
@ -3925,14 +3933,21 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
BfTypedValue valueFromExpr; BfTypedValue valueFromExpr;
valueFromExpr = GetFieldInitializerValue(fieldInstance); valueFromExpr = GetFieldInitializerValue(fieldInstance);
FixIntUnknown(valueFromExpr); FixIntUnknown(valueFromExpr);
resolvedType = valueFromExpr.mType;
if (fieldType->IsUndefSizedArray())
{
if ((valueFromExpr.mType != NULL) && (valueFromExpr.mType->IsSizedArray()) && (valueFromExpr.mType->GetUnderlyingType() == fieldType->GetUnderlyingType()))
resolvedType = valueFromExpr.mType;
}
else
resolvedType = valueFromExpr.mType;
} }
mBfIRBuilder->SetInsertPoint(prevInsertBlock); mBfIRBuilder->SetInsertPoint(prevInsertBlock);
} }
if (resolvedType == NULL) if (resolvedType == NULL)
return GetPrimitiveType(BfTypeCode_Var); return fieldType;
fieldInstance->SetResolvedType(resolvedType); fieldInstance->SetResolvedType(resolvedType);
@ -4081,7 +4096,7 @@ BfTypedValue BfModule::GetFieldInitializerValue(BfFieldInstance* fieldInstance,
if ((doStore) && (result)) if ((doStore) && (result))
{ {
if (fieldInstance->mResolvedType->IsUnknownSizedArray()) if (fieldInstance->mResolvedType->IsUndefSizedArray())
{ {
AssertErrorState(); AssertErrorState();
} }

6
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

@ -5234,7 +5234,7 @@ BfTypeInstance* BfModule::GetWrappedStructType(BfType* type, bool allowSpecializ
{ {
if (allowSpecialized) if (allowSpecialized)
{ {
if (type->IsUnknownSizedArray()) if (type->IsUnknownSizedArrayType())
{ {
BfUnknownSizedArrayType* sizedArrayType = (BfUnknownSizedArrayType*)type; BfUnknownSizedArrayType* sizedArrayType = (BfUnknownSizedArrayType*)type;
BfTypeVector typeVector; BfTypeVector typeVector;
@ -6391,7 +6391,7 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty
if (!unspecializedType->IsUnspecializedType()) if (!unspecializedType->IsUnspecializedType())
return unspecializedType; return unspecializedType;
if (unspecializedType->IsUnknownSizedArray()) if (unspecializedType->IsUnknownSizedArrayType())
{ {
auto* arrayType = (BfUnknownSizedArrayType*)unspecializedType; auto* arrayType = (BfUnknownSizedArrayType*)unspecializedType;
auto elementType = ResolveGenericType(arrayType->mElementType, typeGenericArguments, methodGenericArguments, allowFail); auto elementType = ResolveGenericType(arrayType->mElementType, typeGenericArguments, methodGenericArguments, allowFail);
@ -12445,7 +12445,7 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF
DoTypeToString(str, concreteTypeType->mInterface, typeNameFlags, genericMethodNameOverrides); DoTypeToString(str, concreteTypeType->mInterface, typeNameFlags, genericMethodNameOverrides);
return; return;
} }
else if (resolvedType->IsUnknownSizedArray()) else if (resolvedType->IsUnknownSizedArrayType())
{ {
auto arrayType = (BfUnknownSizedArrayType*)resolvedType; auto arrayType = (BfUnknownSizedArrayType*)resolvedType;
DoTypeToString(str, arrayType->mElementType, typeNameFlags, genericMethodNameOverrides); DoTypeToString(str, arrayType->mElementType, typeNameFlags, genericMethodNameOverrides);

6
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -2785,7 +2785,7 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
auto sizedArray = (BfSizedArrayType*)type; auto sizedArray = (BfSizedArrayType*)type;
int elemHash = Hash(sizedArray->mElementType, ctx) ^ HASH_SIZED_ARRAY; int elemHash = Hash(sizedArray->mElementType, ctx) ^ HASH_SIZED_ARRAY;
int hashVal = (elemHash << 5) - elemHash; int hashVal = (elemHash << 5) - elemHash;
if (type->IsUnknownSizedArray()) if (type->IsUnknownSizedArrayType())
{ {
auto unknownSizedArray = (BfUnknownSizedArrayType*)type; auto unknownSizedArray = (BfUnknownSizedArrayType*)type;
int elemHash = Hash(unknownSizedArray->mElementCountSource, ctx); int elemHash = Hash(unknownSizedArray->mElementCountSource, ctx);
@ -4060,7 +4060,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
BfTypedValue typedVal = constResolver.Resolve(sizeExpr, NULL, BfConstResolveFlag_ArrayInitSize); BfTypedValue typedVal = constResolver.Resolve(sizeExpr, NULL, BfConstResolveFlag_ArrayInitSize);
if (typedVal.mKind == BfTypedValueKind_GenericConstValue) if (typedVal.mKind == BfTypedValueKind_GenericConstValue)
{ {
if (!lhs->IsUnknownSizedArray()) if (!lhs->IsUnknownSizedArrayType())
return false; return false;
auto lhsUnknownSizedArray = (BfUnknownSizedArrayType*)lhs; auto lhsUnknownSizedArray = (BfUnknownSizedArrayType*)lhs;
@ -4070,7 +4070,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
typedVal = ctx->mModule->Cast(sizeExpr, typedVal, intType); typedVal = ctx->mModule->Cast(sizeExpr, typedVal, intType);
if (typedVal) if (typedVal)
{ {
if (lhs->IsUnknownSizedArray()) if (lhs->IsUnknownSizedArrayType())
return false; return false;
auto constant = ctx->mModule->mBfIRBuilder->GetConstant(typedVal.mValue); auto constant = ctx->mModule->mBfIRBuilder->GetConstant(typedVal.mValue);

4
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -530,7 +530,7 @@ public:
virtual bool IsString() { return false; } virtual bool IsString() { return false; }
virtual bool IsSizedArray() { return false; } virtual bool IsSizedArray() { return false; }
virtual bool IsUndefSizedArray() { return false; } virtual bool IsUndefSizedArray() { return false; }
virtual bool IsUnknownSizedArray() { return false; } virtual bool IsUnknownSizedArrayType() { return false; }
virtual bool IsArray() { return false; } virtual bool IsArray() { return false; }
virtual bool IsDelegate() { return false; } virtual bool IsDelegate() { return false; }
virtual bool IsFunction() { return false; } virtual bool IsFunction() { return false; }
@ -2308,7 +2308,7 @@ public:
public: public:
virtual bool NeedsExplicitAlignment() override { return mElementType->NeedsExplicitAlignment(); } virtual bool NeedsExplicitAlignment() override { return mElementType->NeedsExplicitAlignment(); }
virtual bool IsUnknownSizedArray() override { return true; } virtual bool IsUnknownSizedArrayType() override { return true; }
virtual bool IsWrappableType() override { return true; } virtual bool IsWrappableType() override { return true; }
virtual bool IsValueType() override { return true; } // Is a type of struct virtual bool IsValueType() override { return true; } // Is a type of struct