SemanticFunction.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
// uLang Compiler Public API
 
#pragma once
 
#include "uLang/Semantics/CaptureScope.h"
#include "uLang/Semantics/ControlScope.h"
#include "uLang/Semantics/Definition.h"
#include "uLang/Semantics/Expression.h"
#include "uLang/Semantics/Revision.h"
#include "uLang/Semantics/Signature.h"
#include "uLang/Semantics/SemanticTypes.h"
#include "uLang/Common/Text/Named.h"
#include "uLang/Common/Misc/Optional.h"
 
#define UE_API VERSECOMPILER_API
 
namespace uLang
{
 
enum class EFunctionStringFlag : uint16_t
{
    Simple            = 0x0,  // function(:Type1,:Type2)
    Qualified         = 1<<1, // Prepends the scope `(/MyModule:)` (unless async or native) and then the name of the function
    QualifiedParams   = 1<<2, // Preform similar qualification of parameters
    QualifiedVersion1 = Qualified,
    QualifiedVersion2 = Qualified|QualifiedParams
};
 
/* No longer used, but good ideas
enum class EFunctionStringFlag : uint16_t
{
    // Name part - omitted or one of:
    Name          = 1<<0,  // Prepend name of function
    Qualified     = 1<<1,  // Prepends the scope `(/MyModule:)` and then the name of the function
 
    // Type signature part - omitted or one of:
    SigSimple     = 1<<2,  // Include just parentheses ()
    SigTyped      = 1<<3,  // Include parentheses (), any parameter names and types and result type (param1 : Type1, param2 : Type2) : ResultType
    SigDefaults   = 1<<4,  // Include parentheses (), any parameter names, types and defaults and result type (param1 : Type1, param2 : Type2 = default2 ) : ResultType
 
    // Body - omitted or one of:
    BodyIndicator = 1<<5,  // {...} for uLang body and empty for atomic C++ body
    Body          = 1<<6,  // full uLang body or empty for atomic C++ body
 
    // Spacing - omitted (canonical with multi-line) or:
    Inline        = 1<<7,  // try to have everything on one line
 
        // Masks
        Default_ = Qualified|SigDefaults|Body,  // MyClass@function(param1 : Type1, param2 : Type2 = default2 ) : ResultType { }
        DefaultUnnamed_ = SigDefaults|Body,     // (param1 : Type1, param2 : Type2 = default2 ) : ResultType { }
        DefaultIdent_ = Qualified|SigSimple,    // MyClass@function()
 
        Named_ = Name|Qualified,
        Signature_ = SigSimple|SigTyped|SigDefaults,
        Body_ = BodyIndicator|Body,
        Unimplemented_ = SigTyped|SigDefaults|Body
};
*/
 
enum class EExtensionFieldAccessorKind
{
    Function,
    ExtensionDataMember,
    ExtensionMethod
};
 
class CFunction : public CDefinition, public CLogicalScope, public CCaptureScope
{
public:
    static const CDefinition::EKind StaticDefinitionKind = CDefinition::EKind::Function;
    friend class CExprFunctionDefinition;
 
    SSignature _Signature;
 
    EExtensionFieldAccessorKind _ExtensionFieldAccessorKind = EExtensionFieldAccessorKind::Function;
 
    const CFunctionType* _NegativeType = nullptr;
 
    TArray<const CFunction*> _LowerIdenticalFunctions;
 
    UE_API CFunction(const int32_t Index, const CSymbol& FunctionName, CScope& EnclosingScope);
 
    UE_API int32_t Index() const;
 
    //~ Begin CScope interface
    virtual CSymbol GetScopeName() const override { return CNamed::GetName(); }
    virtual const CDefinition* ScopeAsDefinition() const override { return this; }
    //~ End CScope interface
 
    void SetOverriddenDefinition(const CFunction& OverriddenDefinition) { CDefinition::SetOverriddenDefinition(OverriddenDefinition); }
    void SetOverriddenDefinition(const CFunction* OverriddenDefinition) { CDefinition::SetOverriddenDefinition(OverriddenDefinition); }
    const CFunction* GetOverriddenDefinition() const
    {
        const CDefinition* OverriddenDefinition = CDefinition::GetOverriddenDefinition();
        return OverriddenDefinition ? &OverriddenDefinition->AsChecked<CFunction>() : nullptr;
    }
    const CFunction& GetBaseOverriddenDefinition() const
    {
        return CDefinition::GetBaseOverriddenDefinition().AsChecked<CFunction>();
    }
 
    const CFunction& GetBaseCoercedOverriddenFunction() const
    {
        const CFunction* I = this;
        for (;;)
        {
            if (I->GetPrototypeDefinition()->IsCoercedOverride())
            {
                break;
            }
            const CFunction* Next = I->GetOverriddenDefinition();
            if (!Next)
            {
                break;
            }
            I = Next;
        }
        return *I;
    }
 
    UE_API void SetSignature(SSignature&& Signature, SemanticRevision NextRevision);
    UE_API void MapSignature(const CFunctionType& FuncType, SemanticRevision NextRevision);
 
    TSPtr<CExpressionBase> GetBodyAst() const { ULANG_ASSERTF(!GetIrNode(true), "Called AST function on when IR available");  return GetAstNode() ? GetAstNode()->Value() : nullptr; }
 
    UE_API TSPtr<CExprClassDefinition> GetBodyClassDefinitionAst() const;
 
    UE_API TSPtr<CExprInterfaceDefinition> GetBodyInterfaceDefinitionAst() const;
 
    TSPtr<CExpressionBase> GetReturnTypeAst() const { ULANG_ASSERTF(!GetIrNode(true), "Called AST function on when IR available");  return GetAstNode() ? GetAstNode()->ValueDomain() : nullptr; }
    
    TSPtr<CExpressionBase> GetDefineeAst() const { ULANG_ASSERTF(!GetIrNode(true), "Called AST function on when IR available"); return GetAstNode() ? GetAstNode()->Element() : nullptr; }
 
    CExpressionBase* GetBodyIr() const { return GetIrNode()->Value(); }
 
    UE_API CExprClassDefinition* GetBodyClassDefinitionIr() const;
 
    UE_API CExprInterfaceDefinition* GetBodyInterfaceDefinitionIr() const;
 
    CExpressionBase* GetReturnTypeIr() const { return GetIrNode()->ValueDomain(); }
 
    SemanticRevision GetRevision() const { return CMath::Max(_SignatureRevision, _BodyRevision); }
    SemanticRevision GetSignatureRevision() const { return _SignatureRevision; }
    SemanticRevision GetBodyRevision() const { return _BodyRevision; }
 
    UE_API TOptional<const CClass*> GetMaybeClassScope() const;
    UE_API TOptional<const CModule*> GetMaybeModuleScope() const;
    UE_API TOptional<const CNominalType*> GetMaybeContextType() const;
 
    UE_API CUTF8String GetDecoratedName(uint16_t StrFlags = uint16_t(EFunctionStringFlag::QualifiedVersion2)) const;
 
    /* Returns the qualifier in canonical form */
    UE_API CUTF8String GetQualifier() const;
 
    void MarkCoercion(const CFunction& CoercedFrom) { _CoercedOriginalFunction = &CoercedFrom; }
 
    bool IsCoercion() const { return _CoercedOriginalFunction != nullptr; }
 
    void MarkCoercedOverride() { _bCoercedOverride = true; }
 
    bool IsCoercedOverride() const { return _bCoercedOverride; }
 
    UE_API bool HasImplementation() const;
 
    UE_API bool IsNative() const;
 
    UE_API bool IsConstructor() const;
 
    // CDefinition interface.
    void SetPrototypeDefinition(const CFunction& PrototypeDefinition) { CDefinition::SetPrototypeDefinition(PrototypeDefinition); }
    const CFunction* GetPrototypeDefinition() const { return static_cast<const CFunction*>(CDefinition::GetPrototypeDefinition()); }
 
    UE_API void SetAstNode(CExprFunctionDefinition* AstNode);
    UE_API CExprFunctionDefinition* GetAstNode() const;
 
    UE_API void SetIrNode(CExprFunctionDefinition* AstNode);
    UE_API CExprFunctionDefinition* GetIrNode(bool bForce = false) const;
 
    virtual const CLogicalScope* DefinitionAsLogicalScopeNullable() const override { return this; }
 
    virtual bool IsPersistenceCompatConstraint() const override { return false; }
 
    virtual CCaptureScope* GetParentCaptureScope() const override
    {
        return _EnclosingScope.GetCaptureScope();
    }
 
    mutable bool _bIsAccessorOfSomeClassVar = false; // HACK: using mutable here to set this after the fact
 
    UE_API bool CanBeCalledFromPredicts() const;
    UE_API const CFunction* GetPredictsCoercedOriginalFunction() const;
 
private:
    const int32_t _Index;
 
    const CFunction* _CoercedOriginalFunction{nullptr};
 
    bool _bCoercedOverride{false};
 
    SemanticRevision _SignatureRevision;
 
    SemanticRevision _BodyRevision;
};
 
}  // namespace uLang
 
#undef UE_API