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

Added alloctype(T)

Browse source
This commit is contained in:
Brian Fiete 2020-08-12 15:07:56 -07:00
parent a4abd54e7d
commit 9d5d5b4063
12 changed files with 95 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

2
IDEHelper/Compiler/BfAst.cpp
View file

@ -1228,6 +1228,8 @@ const char* Beefy::BfTokenToString(BfToken token)
return "abstract";
case BfToken_AlignOf:
return "alignof";
case BfToken_AllocType:
return "alloctype";
case BfToken_Append:
return "append";
case BfToken_As:

1
IDEHelper/Compiler/BfAst.h
View file

@ -105,6 +105,7 @@ enum BfToken : uint8
BfToken_None,
BfToken_Abstract,
BfToken_AlignOf,
BfToken_AllocType,
BfToken_Append,
BfToken_As,
BfToken_Asm,

29
IDEHelper/Compiler/BfAutoComplete.cpp
View file

@ -315,13 +315,24 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
{
SetAndRestoreValue<bool> prevIgnoreClassifying(mModule->mIsInsideAutoComplete, true);
auto _FixType = [](const BfTypedValue& typedValue)
{
if ((typedValue.mType != NULL) && (typedValue.mType->IsAllocType()))
{
BfTypedValue ret = typedValue;
ret.mType = ret.mType->GetUnderlyingType();
return ret;
}
return typedValue;
};
if (auto typeRef = BfNodeDynCast<BfTypeReference>(node))
{
auto type = mModule->ResolveTypeRef(typeRef);
if (type != NULL)
{
*isStatic = true;
return BfTypedValue(type);
return _FixType(BfTypedValue(type));
}
if (auto namedTypeRef = BfNodeDynCast<BfNamedTypeReference>(typeRef))
@ -330,7 +341,7 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
auto identifierResult = exprEvaluator.LookupIdentifier(namedTypeRef->mNameNode);
if (identifierResult)
return identifierResult;
return exprEvaluator.GetResult(); // We need 'GetResult' to read property values
return _FixType(exprEvaluator.GetResult()); // We need 'GetResult' to read property values
}
else if (auto qualifiedTypeRef = BfNodeDynCast<BfQualifiedTypeReference>(typeRef))
{
@ -356,7 +367,7 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
if (!fieldResult) // Was property?
fieldResult = exprEvaluator.GetResult();
*isStatic = false;
return fieldResult;
return _FixType(fieldResult);
}
}
}
@ -368,7 +379,7 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
if (!identifierResult)
identifierResult = exprEvaluator.GetResult();
if (identifierResult)
return identifierResult;
return _FixType(identifierResult);
if (auto qualifiedIdentifier = BfNodeDynCast<BfQualifiedNameNode>(node))
{
@ -388,7 +399,7 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
return fieldResult;
auto result = exprEvaluator.GetResult();
if (result)
return result;
return _FixType(result);
}
}
@ -396,22 +407,22 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
if (type != NULL)
{
*isStatic = true;
return BfTypedValue(type);
return _FixType(BfTypedValue(type));
}
}
else if (auto memberRefExpr = BfNodeDynCast<BfMemberReferenceExpression>(node))
{
return mModule->CreateValueFromExpression(memberRefExpr, expectingType, evalExprFlags);
return _FixType(mModule->CreateValueFromExpression(memberRefExpr, expectingType, evalExprFlags));
}
else if (auto parenExpr = BfNodeDynCast<BfParenthesizedExpression>(node))
{
// Don't pass BfEvalExprFlags_IgnoreNullConditional, since parenExprs end nullable chains and we actually
// DO want the nullable at this point
return mModule->CreateValueFromExpression(parenExpr);
return _FixType(mModule->CreateValueFromExpression(parenExpr));
}
else if (auto targetExpr = BfNodeDynCast<BfExpression>(node))
{
return mModule->CreateValueFromExpression(targetExpr, NULL, evalExprFlags);
return _FixType(mModule->CreateValueFromExpression(targetExpr, NULL, evalExprFlags));
}
return BfTypedValue();

2
IDEHelper/Compiler/BfContext.h
View file

@ -380,7 +380,7 @@ public:
BfAllocPool<BfTupleType> mTupleTypePool;
BfAllocPool<BfTypeAliasType> mAliasTypePool;
BfAllocPool<BfRefType> mRefTypePool;
BfAllocPool<BfModifiedTypeType> mRetTypeTypePool;
BfAllocPool<BfModifiedTypeType> mModifiedTypeTypePool;
BfAllocPool<BfTypeInstance> mGenericTypeInstancePool;
BfAllocPool<BfArrayType> mArrayTypeInstancePool;
BfAllocPool<BfGenericParamType> mGenericParamTypePool;

34
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -7997,8 +7997,8 @@ void BfExprEvaluator::LookupQualifiedName(BfAstNode* nameNode, BfIdentifierNode*
if (!mResult)
return;
//if (mResult.mType->IsVar())
//ResolveGenericType();
if (mResult.mType->IsAllocType())
mResult.mType = mResult.mType->GetUnderlyingType();
auto origResult = mResult;
auto lookupType = BindGenericType(nameNode, mResult.mType);
@ -12289,26 +12289,33 @@ void BfExprEvaluator::Visit(BfObjectCreateExpression* objCreateExpr)
bool isGenericParam = unresolvedTypeRef->IsGenericParam();
if (resolvedTypeRef->IsGenericParam())
{
auto genericConstraint = mModule->GetGenericParamInstance((BfGenericParamType*)resolvedTypeRef);
if (genericConstraint->mTypeConstraint == NULL)
auto genericParam = mModule->GetGenericParamInstance((BfGenericParamType*)resolvedTypeRef);
if (genericParam->mTypeConstraint == NULL)
{
if ((genericConstraint->mGenericParamFlags & BfGenericParamFlag_New) == 0)
if ((genericParam->mGenericParamFlags & BfGenericParamFlag_New) == 0)
{
mModule->Fail(StrFormat("Must add 'where %s : new' constraint to generic parameter to instantiate type", genericConstraint->GetGenericParamDef()->mName.c_str()), objCreateExpr->mTypeRef);
mModule->Fail(StrFormat("Must add 'where %s : new' constraint to generic parameter to instantiate type", genericParam->GetName().c_str()), objCreateExpr->mTypeRef);
}
if (objCreateExpr->mArguments.size() != 0)
{
mModule->Fail(StrFormat("Only default parameterless constructors can be called on generic argument '%s'", genericConstraint->GetGenericParamDef()->mName.c_str()), objCreateExpr->mTypeRef);
mModule->Fail(StrFormat("Only default parameterless constructors can be called on generic argument '%s'", genericParam->GetName().c_str()), objCreateExpr->mTypeRef);
}
}
if (((genericParam->mTypeConstraint != NULL) && (genericParam->mTypeConstraint->IsValueType())) ||
((genericParam->mGenericParamFlags & (BfGenericParamFlag_Struct | BfGenericParamFlag_StructPtr)) != 0))
{
resultType = mModule->CreatePointerType(resolvedTypeRef);
}
else if (((genericParam->mTypeConstraint != NULL) && (!genericParam->mTypeConstraint->IsValueType())) ||
((genericParam->mGenericParamFlags & (BfGenericParamFlag_Class)) != 0))
{
// Leave as 'T'
resultType = resolvedTypeRef;
bool isValueType = ((genericConstraint->mGenericParamFlags & BfGenericParamFlag_Struct) != 0);
if (genericConstraint->mTypeConstraint != NULL)
isValueType = genericConstraint->mTypeConstraint->IsValueType();
}
else
resultType = mModule->CreateModifiedTypeType(resolvedTypeRef, BfToken_AllocType);
if (isValueType)
resultType = mModule->CreatePointerType(resultType);
mResult.mType = resultType;
if (typeInstance == NULL)
@ -14549,6 +14556,9 @@ void BfExprEvaluator::DoInvocation(BfAstNode* target, BfMethodBoundExpression* m
bool mayBeSkipCall = false;
if (thisValue.mType != NULL)
{
if (thisValue.mType->IsAllocType())
thisValue.mType = thisValue.mType->GetUnderlyingType();
auto checkTypeInst = thisValue.mType->ToTypeInstance();
while (checkTypeInst != NULL)
{

4
IDEHelper/Compiler/BfMangler.cpp
View file

@ -555,6 +555,8 @@ void BfGNUMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType
BfModifiedTypeType* retTypeType = (BfModifiedTypeType*)type;
if (retTypeType->mModifiedKind == BfToken_RetType)
name += "U7rettype";
else if (retTypeType->mModifiedKind == BfToken_AllocType)
name += "U5alloc";
else if (retTypeType->mModifiedKind == BfToken_Nullable)
name += "U8nullable";
else
@ -1621,6 +1623,8 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType*
auto retType = (BfModifiedTypeType*)type;
if (retType->mModifiedKind == BfToken_RetType)
name += "rettype$";
else if (retType->mModifiedKind == BfToken_AllocType)
name += "alloc$";
else if (retType->mModifiedKind == BfToken_Nullable)
name += "nullable$";
else

21
IDEHelper/Compiler/BfModuleTypeUtils.cpp
View file

@ -5488,13 +5488,13 @@ BfRefType* BfModule::CreateRefType(BfType* resolvedTypeRef, BfRefType::RefKind r
BfModifiedTypeType* BfModule::CreateModifiedTypeType(BfType* resolvedTypeRef, BfToken modifiedKind)
{
auto retTypeType = mContext->mRetTypeTypePool.Get();
auto retTypeType = mContext->mModifiedTypeTypePool.Get();
retTypeType->mContext = mContext;
retTypeType->mModifiedKind = modifiedKind;
retTypeType->mElementType = resolvedTypeRef;
auto resolvedRetTypeType = ResolveType(retTypeType);
if (resolvedRetTypeType != retTypeType)
mContext->mRetTypeTypePool.GiveBack(retTypeType);
mContext->mModifiedTypeTypePool.GiveBack(retTypeType);
return (BfModifiedTypeType*)resolvedRetTypeType;
}
@ -8121,6 +8121,23 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula
return ResolveTypeResult(typeRef, resolvedType, populateType, resolveFlags);
}
}
else if (retTypeTypeRef->mRetTypeToken->mToken == BfToken_AllocType)
{
BfType* resolvedType = NULL;
if (retTypeTypeRef->mElementType != NULL)
{
resolvedType = ResolveTypeRef(retTypeTypeRef->mElementType, BfPopulateType_Declaration, BfResolveTypeRefFlag_AllowGenericParamConstValue);
if (resolvedType != NULL)
{
if (resolvedType->IsGenericParam())
resolvedType = CreateModifiedTypeType(resolvedType, BfToken_AllocType);
else if (resolvedType->IsValueType())
resolvedType = CreatePointerType(resolvedType);
}
}
return ResolveTypeResult(typeRef, resolvedType, populateType, resolveFlags);
}
else if (retTypeTypeRef->mRetTypeToken->mToken == BfToken_Nullable)
{
bool allowThrough = false;

4
IDEHelper/Compiler/BfParser.cpp
View file

@ -2628,6 +2628,10 @@ void BfParser::NextToken(int endIdx)
if ((!mCompatMode) && (SrcPtrHasToken("abstract")))
mToken = BfToken_Abstract;
break;
case TOKEN_HASH('a', 'l', 'l', 'o'):
if (SrcPtrHasToken("alloctype"))
mToken = BfToken_AllocType;
break;
case TOKEN_HASH('a', 'l', 'i', 'g'):
if (SrcPtrHasToken("alignof"))
mToken = BfToken_AlignOf;

8
IDEHelper/Compiler/BfReducer.cpp
View file

@ -267,7 +267,7 @@ bool BfReducer::IsTypeReference(BfAstNode* checkNode, BfToken successToken, int*
{
// Tuple start
}
else if ((checkToken == BfToken_Decltype) || (checkToken == BfToken_RetType) || (checkToken == BfToken_Nullable))
else if ((checkToken == BfToken_Decltype) || (checkToken == BfToken_AllocType) || (checkToken == BfToken_RetType) || (checkToken == BfToken_Nullable))
{
// Decltype start
}
@ -774,7 +774,7 @@ bool BfReducer::IsTypeReference(BfAstNode* checkNode, BfToken successToken, int*
checkIdx = funcEndNode;
continue;
}
else if ((checkToken == BfToken_Decltype) || (checkToken == BfToken_RetType) || (checkToken == BfToken_Nullable))
else if ((checkToken == BfToken_Decltype) || (checkToken == BfToken_AllocType) || (checkToken == BfToken_RetType) || (checkToken == BfToken_Nullable))
{
int endNodeIdx = checkIdx + 1;
@ -4216,6 +4216,7 @@ bool BfReducer::IsTerminatingExpression(BfAstNode* node)
break;
case BfToken_As:
case BfToken_AllocType:
case BfToken_Append:
case BfToken_Default:
case BfToken_Is:
@ -4626,7 +4627,7 @@ BfTypeReference* BfReducer::DoCreateTypeRef(BfAstNode* firstNode, CreateTypeRefF
return elementType;
}
}
else if ((token == BfToken_RetType) || (token == BfToken_Nullable))
else if ((token == BfToken_AllocType) || (token == BfToken_Nullable) || (token == BfToken_RetType))
{
auto retTypeTypeRef = mAlloc->Alloc<BfModifiedTypeRef>();
ReplaceNode(firstNode, retTypeTypeRef);
@ -6373,6 +6374,7 @@ BfAstNode* BfReducer::ReadTypeMember(BfAstNode* node, int depth)
}
else if ((token == BfToken_Var) ||
(token == BfToken_Let) ||
(token == BfToken_AllocType) ||
(token == BfToken_RetType) ||
(token == BfToken_Nullable) ||
(token == BfToken_Decltype) ||

8
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -2452,7 +2452,7 @@ BfResolvedTypeSet::~BfResolvedTypeSet()
#define HASH_VAL_REF 3
#define HASH_VAL_OUT 4
#define HASH_VAL_MUT 5
#define HASH_RETTYPE 6
#define HASH_MODTYPE 6
#define HASH_CONCRETE_INTERFACE 7
#define HASH_SIZED_ARRAY 8
#define HASH_CONSTTYPE 9
@ -2627,8 +2627,8 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
}
else if (type->IsModifiedTypeType())
{
auto retTypeType = (BfModifiedTypeType*)type;
int elemHash = Hash(retTypeType->mElementType, ctx) ^ HASH_RETTYPE;
auto modifiedTypeType = (BfModifiedTypeType*)type;
int elemHash = Hash(modifiedTypeType->mElementType, ctx) ^ HASH_MODTYPE + (int)modifiedTypeType->mModifiedKind;
return (elemHash << 5) - elemHash;
}
else if (type->IsConcreteInterfaceType())
@ -3095,7 +3095,7 @@ int BfResolvedTypeSet::Hash(BfTypeReference* typeRef, LookupContext* ctx, BfHash
return Hash(type, ctx, flags);
}
int elemHash = Hash(retTypeTypeRef->mElementType, ctx) ^ HASH_RETTYPE;
int elemHash = Hash(retTypeTypeRef->mElementType, ctx) ^ HASH_MODTYPE + retTypeTypeRef->mRetTypeToken->mToken;
return (elemHash << 5) - elemHash;
}
else if (auto resolvedTypeRef = BfNodeDynCastExact<BfResolvedTypeReference>(typeRef))

3
IDEHelper/Compiler/BfResolvedTypeUtils.h
View file

@ -538,6 +538,7 @@ public:
virtual bool IsChar() { return false; }
virtual bool IsFloat() { return false; }
virtual bool IsPointer() { return false; }
virtual bool IsAllocType() { return false; }
virtual bool IsIntPtrable() { return false; }
virtual bool IsRef() { return false; }
virtual bool IsGenericParam() { return false; }
@ -999,8 +1000,10 @@ public:
virtual bool IsValuelessType() override { return true; }
virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); }
virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedType(); }
virtual bool IsReified() override { return mElementType->IsReified(); }
virtual bool IsDependentOnUnderlyingType() override { return true; }
virtual bool IsAllocType() { return mModifiedKind == BfToken_AllocType; }
virtual BfType* GetUnderlyingType() override { return mElementType; }
};

2
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

@ -3807,6 +3807,8 @@ void BfModule::Visit(BfDeleteStatement* deleteStmt)
if (!val)
return;
if (val.mType->IsAllocType())
val.mType = val.mType->GetUnderlyingType();
BfGenericParamType* genericType = NULL;
if (val.mType->IsGenericParam())