mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-13 21:40:43 +00:00
42a2805f85
* A small subset of control-flow refinements have been added to recognize type options that are unreachable after a conditional/unconditional code block. (Fixes https://github.com/Roblox/luau/issues/356). Some examples: ```lua local function f(x: string?) if not x then return end -- x is 'string' here end ``` Throwing calls like `error` or `assert(false)` instead of 'return' are also recognized. Existing complex refinements like type/typeof and tagged union checks are expected to work, among others. To enable this feature, `LuauTinyControlFlowAnalysis` exclusion has to be removed from `ExperimentalFlags.h`. If will become enabled unconditionally in the near future. * Linter has been integrated into the typechecker analysis so that type-aware lint warnings can work in any mode `Frontend::lint` methods were deprecated, `Frontend::check` has to be used instead with `runLintChecks` option set. Resulting lint warning are located inside `CheckResult`. * Fixed large performance drop and increased memory consumption when array is filled at an offset (Fixes https://github.com/Roblox/luau/issues/590) * Part of [Type error suppression RFC](https://github.com/Roblox/luau/blob/master/rfcs/type-error-suppression.md) was implemented making subtyping checks with `any` type transitive. --- In our work on the new type-solver: * `--!nocheck` mode no longer reports type errors * New solver will not be used for `--!nonstrict` modules until all issues with strict mode typechecking are fixed * Added control-flow aware type refinements mentioned earlier In native code generation: * `LOP_NAMECALL` has been translated to IR * `type` and `typeof` builtin fastcalls have been translated to IR/assembly * Additional steps were taken towards arm64 support
83 lines
1.8 KiB
C++
83 lines
1.8 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
#pragma once
|
|
|
|
#include <bitset>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <stdint.h>
|
|
|
|
namespace Luau
|
|
{
|
|
namespace CodeGen
|
|
{
|
|
|
|
struct IrBlock;
|
|
struct IrFunction;
|
|
|
|
void updateUseCounts(IrFunction& function);
|
|
|
|
void updateLastUseLocations(IrFunction& function);
|
|
|
|
// Returns how many values are coming into the block (live in) and how many are coming out of the block (live out)
|
|
std::pair<uint32_t, uint32_t> getLiveInOutValueCount(IrFunction& function, IrBlock& block);
|
|
uint32_t getLiveInValueCount(IrFunction& function, IrBlock& block);
|
|
uint32_t getLiveOutValueCount(IrFunction& function, IrBlock& block);
|
|
|
|
struct RegisterSet
|
|
{
|
|
std::bitset<256> regs;
|
|
|
|
// If variadic sequence is active, we track register from which it starts
|
|
bool varargSeq = false;
|
|
uint8_t varargStart = 0;
|
|
};
|
|
|
|
struct CfgInfo
|
|
{
|
|
std::vector<uint32_t> predecessors;
|
|
std::vector<uint32_t> predecessorsOffsets;
|
|
|
|
std::vector<uint32_t> successors;
|
|
std::vector<uint32_t> successorsOffsets;
|
|
|
|
std::vector<RegisterSet> in;
|
|
std::vector<RegisterSet> def;
|
|
std::vector<RegisterSet> out;
|
|
|
|
RegisterSet captured;
|
|
};
|
|
|
|
void computeCfgInfo(IrFunction& function);
|
|
|
|
struct BlockIteratorWrapper
|
|
{
|
|
uint32_t* itBegin = nullptr;
|
|
uint32_t* itEnd = nullptr;
|
|
|
|
bool empty() const
|
|
{
|
|
return itBegin == itEnd;
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
return size_t(itEnd - itBegin);
|
|
}
|
|
|
|
uint32_t* begin() const
|
|
{
|
|
return itBegin;
|
|
}
|
|
|
|
uint32_t* end() const
|
|
{
|
|
return itEnd;
|
|
}
|
|
};
|
|
|
|
BlockIteratorWrapper predecessors(CfgInfo& cfg, uint32_t blockIdx);
|
|
BlockIteratorWrapper successors(CfgInfo& cfg, uint32_t blockIdx);
|
|
|
|
} // namespace CodeGen
|
|
} // namespace Luau
|