mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-13 13:30:40 +00:00
721f6e10fb
Lots of things going on this week: * Fix a crash that could occur in the presence of a cyclic union. We shouldn't be creating cyclic unions, but we shouldn't be crashing when they arise either. * Minor cleanup of `luau_precall` * Internal change to make L->top handling slightly more uniform * Optimize SETGLOBAL & GETGLOBAL fallback C functions. * https://github.com/Roblox/luau/pull/929 * The syntax to the `luau-reduce` commandline tool has changed. It now accepts a script, a command to execute, and an error to search for. It no longer automatically passes the script to the command which makes it a lot more flexible. Also be warned that it edits the script it is passed **in place**. Do not point it at something that is not in source control! New solver * Switch to a greedier but more fallible algorithm for simplifying union and intersection types that are created as part of refinement calculation. This has much better and more predictable performance. * Fix a constraint cycle in recursive function calls. * Much improved inference of binary addition. Functions like `function add(x, y) return x + y end` can now be inferred without annotations. We also accurately typecheck calls to functions like this. * Many small bugfixes surrounding things like table indexers * Add support for indexers on class types. This was previously added to the old solver; we now add it to the new one for feature parity. JIT * https://github.com/Roblox/luau/pull/931 * Fuse key.value and key.tt loads for CEHCK_SLOT_MATCH in A64 * Implement remaining aliases of BFM for A64 * Implement new callinfo flag for A64 * Add instruction simplification for int->num->int conversion chains * Don't even load execdata for X64 calls * Treat opcode fallbacks the same as manually written fallbacks --------- Co-authored-by: Arseny Kapoulkine <arseny.kapoulkine@gmail.com> Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
144 lines
4.7 KiB
C++
144 lines
4.7 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/Common.h"
|
|
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
LUAU_FASTINT(LuauTableTypeMaximumStringifierLength)
|
|
LUAU_FASTINT(LuauTypeMaximumStringifierLength)
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
class AstExpr;
|
|
|
|
struct Scope;
|
|
|
|
struct Type;
|
|
using TypeId = const Type*;
|
|
|
|
struct TypePackVar;
|
|
using TypePackId = const TypePackVar*;
|
|
|
|
struct FunctionType;
|
|
struct Constraint;
|
|
|
|
struct Position;
|
|
struct Location;
|
|
|
|
struct ToStringNameMap
|
|
{
|
|
std::unordered_map<TypeId, std::string> types;
|
|
std::unordered_map<TypePackId, std::string> typePacks;
|
|
};
|
|
|
|
struct ToStringOptions
|
|
{
|
|
bool exhaustive = false; // If true, we produce complete output rather than comprehensible output
|
|
bool useLineBreaks = false; // If true, we insert new lines to separate long results such as table entries/metatable.
|
|
bool functionTypeArguments = false; // If true, output function type argument names when they are available
|
|
bool hideTableKind = false; // If true, all tables will be surrounded with plain '{}'
|
|
bool hideNamedFunctionTypeParameters = false; // If true, type parameters of functions will be hidden at top-level.
|
|
bool hideFunctionSelfArgument = false; // If true, `self: X` will be omitted from the function signature if the function has self
|
|
size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypes
|
|
size_t maxTypeLength = size_t(FInt::LuauTypeMaximumStringifierLength);
|
|
ToStringNameMap nameMap;
|
|
std::shared_ptr<Scope> scope; // If present, module names will be added and types that are not available in scope will be marked as 'invalid'
|
|
std::vector<std::string> namedFunctionOverrideArgNames; // If present, named function argument names will be overridden
|
|
};
|
|
|
|
struct ToStringResult
|
|
{
|
|
std::string name;
|
|
|
|
bool invalid = false;
|
|
bool error = false;
|
|
bool cycle = false;
|
|
bool truncated = false;
|
|
};
|
|
|
|
ToStringResult toStringDetailed(TypeId ty, ToStringOptions& opts);
|
|
ToStringResult toStringDetailed(TypePackId ty, ToStringOptions& opts);
|
|
|
|
std::string toString(TypeId ty, ToStringOptions& opts);
|
|
std::string toString(TypePackId ty, ToStringOptions& opts);
|
|
|
|
// These overloads are selected when a temporary ToStringOptions is passed. (eg
|
|
// via an initializer list)
|
|
inline std::string toString(TypePackId ty, ToStringOptions&& opts)
|
|
{
|
|
// Delegate to the overload (TypePackId, ToStringOptions&)
|
|
return toString(ty, opts);
|
|
}
|
|
inline std::string toString(TypeId ty, ToStringOptions&& opts)
|
|
{
|
|
// Delegate to the overload (TypeId, ToStringOptions&)
|
|
return toString(ty, opts);
|
|
}
|
|
|
|
// These are offered as overloads rather than a default parameter so that they can be easily invoked from within the MSVC debugger.
|
|
// You can use them in watch expressions!
|
|
inline std::string toString(TypeId ty)
|
|
{
|
|
return toString(ty, ToStringOptions{});
|
|
}
|
|
inline std::string toString(TypePackId ty)
|
|
{
|
|
return toString(ty, ToStringOptions{});
|
|
}
|
|
|
|
std::string toString(const Constraint& c, ToStringOptions& opts);
|
|
|
|
inline std::string toString(const Constraint& c, ToStringOptions&& opts)
|
|
{
|
|
return toString(c, opts);
|
|
}
|
|
|
|
std::string toString(const Constraint& c);
|
|
|
|
std::string toString(const Type& tv, ToStringOptions& opts);
|
|
std::string toString(const TypePackVar& tp, ToStringOptions& opts);
|
|
|
|
inline std::string toString(const Type& tv)
|
|
{
|
|
ToStringOptions opts;
|
|
return toString(tv, opts);
|
|
}
|
|
|
|
inline std::string toString(const TypePackVar& tp)
|
|
{
|
|
ToStringOptions opts;
|
|
return toString(tp, opts);
|
|
}
|
|
|
|
std::string toStringNamedFunction(const std::string& funcName, const FunctionType& ftv, ToStringOptions& opts);
|
|
|
|
inline std::string toStringNamedFunction(const std::string& funcName, const FunctionType& ftv)
|
|
{
|
|
ToStringOptions opts;
|
|
return toStringNamedFunction(funcName, ftv, opts);
|
|
}
|
|
|
|
std::optional<std::string> getFunctionNameAsString(const AstExpr& expr);
|
|
|
|
// It could be useful to see the text representation of a type during a debugging session instead of exploring the content of the class
|
|
// These functions will dump the type to stdout and can be evaluated in Watch/Immediate windows or as gdb/lldb expression
|
|
std::string dump(TypeId ty);
|
|
std::string dump(const std::optional<TypeId>& ty);
|
|
std::string dump(TypePackId ty);
|
|
std::string dump(const std::optional<TypePackId>& ty);
|
|
std::string dump(const Constraint& c);
|
|
|
|
std::string dump(const std::shared_ptr<Scope>& scope, const char* name);
|
|
|
|
std::string generateName(size_t n);
|
|
|
|
std::string toString(const Position& position);
|
|
std::string toString(const Location& location);
|
|
|
|
} // namespace Luau
|