mirror of
https://github.com/luau-lang/luau.git
synced 2024-11-15 22:35:43 +08:00
140e5a1495
* Fixed incorrect lexeme generated for string parts in the middle of an interpolated string (Fixes https://github.com/Roblox/luau/issues/744) * DeprecatedApi lint can report some issues without type inference information * Fixed performance of autocomplete requests when suggestions have large intersection types (Solves https://github.com/Roblox/luau/discussions/847) * Marked `table.getn`/`foreach`/`foreachi` as deprecated ([RFC: Deprecate table.getn/foreach/foreachi](https://github.com/Roblox/luau/blob/master/rfcs/deprecate-table-getn-foreach.md)) * With -O2 optimization level, we now optimize builtin calls based on known argument/return count. Note that this change can be observable if `getfenv/setfenv` is used to substitute a builtin, especially if arity is different. Fastcall heavy tests show a 1-2% improvement. * Luau can now be built with clang-cl (Fixes https://github.com/Roblox/luau/issues/736) We also made many improvements to our experimental components. For our new type solver: * Overhauled data flow analysis system, fixed issues with 'repeat' loops, global variables and type annotations * Type refinements now work on generic table indexing with a string literal * Type refinements will properly track potentially 'nil' values (like t[x] for a missing key) and their further refinements * Internal top table type is now isomorphic to `{}` which fixes issues when `typeof(v) == 'table'` type refinement is handled * References to non-existent types in type annotations no longer resolve to 'error' type like in old solver * Improved handling of class unions in property access expressions * Fixed default type packs * Unsealed tables can now have metatables * Restored expected types for function arguments And for native code generation: * Added min and max IR instructions mapping to vminsd/vmaxsd on x64 * We now speculatively extract direct execution fast-paths based on expected types of expressions which provides better optimization opportunities inside a single basic block * Translated existing math fastcalls to IR form to improve tag guard removal and constant propagation
84 lines
2.3 KiB
C++
84 lines
2.3 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 "Luau/NotNull.h"
|
|
#include "Luau/TypedAllocator.h"
|
|
#include "Luau/Variant.h"
|
|
|
|
#include <string>
|
|
#include <optional>
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
struct Def;
|
|
using DefId = NotNull<const Def>;
|
|
|
|
/**
|
|
* A cell is a "single-object" value.
|
|
*
|
|
* Leaky implementation note: sometimes "multiple-object" values, but none of which were interesting enough to warrant creating a phi node instead.
|
|
* That can happen because there's no point in creating a phi node that points to either resultant in `if math.random() > 0.5 then 5 else "hello"`.
|
|
* This might become of utmost importance if we wanted to do some backward reasoning, e.g. if `5` is taken, then `cond` must be `truthy`.
|
|
*/
|
|
struct Cell
|
|
{
|
|
};
|
|
|
|
/**
|
|
* A phi node is a union of cells.
|
|
*
|
|
* We need this because we're statically evaluating a program, and sometimes a place may be assigned with
|
|
* different cells, and when that happens, we need a special data type that merges in all the cells
|
|
* that will flow into that specific place. For example, consider this simple program:
|
|
*
|
|
* ```
|
|
* x-1
|
|
* if cond() then
|
|
* x-2 = 5
|
|
* else
|
|
* x-3 = "hello"
|
|
* end
|
|
* x-4 : {x-2, x-3}
|
|
* ```
|
|
*
|
|
* At x-4, we know for a fact statically that either `5` or `"hello"` can flow into the variable `x` after the branch, but
|
|
* we cannot make any definitive decisions about which one, so we just take in both.
|
|
*/
|
|
struct Phi
|
|
{
|
|
std::vector<DefId> operands;
|
|
};
|
|
|
|
/**
|
|
* We statically approximate a value at runtime using a symbolic value, which we call a Def.
|
|
*
|
|
* DataFlowGraphBuilder will allocate these defs as a stand-in for some Luau values, and bind them to places that
|
|
* can hold a Luau value, and then observes how those defs will commute as it statically evaluate the program.
|
|
*
|
|
* It must also be noted that defs are a cyclic graph, so it is not safe to recursively traverse into it expecting it to terminate.
|
|
*/
|
|
struct Def
|
|
{
|
|
using V = Variant<struct Cell, struct Phi>;
|
|
|
|
V v;
|
|
};
|
|
|
|
template<typename T>
|
|
const T* get(DefId def)
|
|
{
|
|
return get_if<T>(&def->v);
|
|
}
|
|
|
|
struct DefArena
|
|
{
|
|
TypedAllocator<Def> allocator;
|
|
|
|
DefId freshCell();
|
|
// TODO: implement once we have cases where we need to merge in definitions
|
|
// DefId phi(const std::vector<DefId>& defs);
|
|
};
|
|
|
|
} // namespace Luau
|