luau-analyzer-sys 0.1.1

A high-performance, embedded Luau type-checking and analysis engine written in Rust. This crate provides bindings to the Luau analyzer, allowing you to integrate static analysis and code intelligence directly into your applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
#include "Luau/BytecodeSummary.h"

#include "Luau/IrUtils.h"

#include "CodeGenLower.h"

#include "lua.h"
#include "lapi.h"
#include "lobject.h"
#include "lstate.h"

namespace Luau
{
namespace CodeGen
{

FunctionBytecodeSummary::FunctionBytecodeSummary(std::string source, std::string name, const int line, unsigned nestingLimit)
    : source(std::move(source))
    , name(std::move(name))
    , line(line)
    , nestingLimit(nestingLimit)
{
    counts.reserve(nestingLimit);
    for (unsigned i = 0; i < 1 + nestingLimit; ++i)
    {
        counts.push_back(std::vector<unsigned>(getOpLimit(), 0));
    }
}

FunctionBytecodeSummary FunctionBytecodeSummary::fromProto(Proto* proto, unsigned nestingLimit)
{
    const char* source = getstr(proto->source);
    source = (source[0] == '=' || source[0] == '@') ? source + 1 : "[string]";

    const char* name = proto->debugname ? getstr(proto->debugname) : "";

    int line = proto->linedefined;

    FunctionBytecodeSummary summary(source, name, line, nestingLimit);

    for (int i = 0; i < proto->sizecode;)
    {
        Instruction insn = proto->code[i];
        uint8_t op = LUAU_INSN_OP(insn);
        summary.incCount(0, op);
        i += getOpLength(LuauOpcode(op));
    }

    return summary;
}

std::vector<FunctionBytecodeSummary> summarizeBytecode(lua_State* L, int idx, unsigned nestingLimit)
{
    CODEGEN_ASSERT(lua_isLfunction(L, idx));
    const TValue* func = luaA_toobject(L, idx);

    Proto* root = clvalue(func)->l.p;

    std::vector<Proto*> protos;
    gatherFunctions(protos, root, CodeGen_ColdFunctions, root->flags & LPF_NATIVE_FUNCTION);

    std::vector<FunctionBytecodeSummary> summaries;
    summaries.reserve(protos.size());

    for (Proto* proto : protos)
    {
        if (proto)
            summaries.push_back(FunctionBytecodeSummary::fromProto(proto, nestingLimit));
    }

    return summaries;
}

} // namespace CodeGen
} // namespace Luau