Sync to upstream/release/568 (#865)

* A small subset of control-flow refinements have been added to
recognize type options that are unreachable after a
conditional/unconditional code block. (Fixes
#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
#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

Analysis/include/Luau/ConstraintGraphBuilder.h

@@ -2,12 +2,13 @@
 #pragma once
 
 #include "Luau/Ast.h"
-#include "Luau/Refinement.h"
 #include "Luau/Constraint.h"
+#include "Luau/ControlFlow.h"
 #include "Luau/DataFlowGraph.h"
 #include "Luau/Module.h"
 #include "Luau/ModuleResolver.h"
 #include "Luau/NotNull.h"
+#include "Luau/Refinement.h"
 #include "Luau/Symbol.h"
 #include "Luau/Type.h"
 #include "Luau/Variant.h"
@@ -141,26 +142,26 @@ struct ConstraintGraphBuilder
      */
     void visit(AstStatBlock* block);
 
-    void visitBlockWithoutChildScope(const ScopePtr& scope, AstStatBlock* block);
-
-    void visit(const ScopePtr& scope, AstStat* stat);
-    void visit(const ScopePtr& scope, AstStatBlock* block);
-    void visit(const ScopePtr& scope, AstStatLocal* local);
-    void visit(const ScopePtr& scope, AstStatFor* for_);
-    void visit(const ScopePtr& scope, AstStatForIn* forIn);
-    void visit(const ScopePtr& scope, AstStatWhile* while_);
-    void visit(const ScopePtr& scope, AstStatRepeat* repeat);
-    void visit(const ScopePtr& scope, AstStatLocalFunction* function);
-    void visit(const ScopePtr& scope, AstStatFunction* function);
-    void visit(const ScopePtr& scope, AstStatReturn* ret);
-    void visit(const ScopePtr& scope, AstStatAssign* assign);
-    void visit(const ScopePtr& scope, AstStatCompoundAssign* assign);
-    void visit(const ScopePtr& scope, AstStatIf* ifStatement);
-    void visit(const ScopePtr& scope, AstStatTypeAlias* alias);
-    void visit(const ScopePtr& scope, AstStatDeclareGlobal* declareGlobal);
-    void visit(const ScopePtr& scope, AstStatDeclareClass* declareClass);
-    void visit(const ScopePtr& scope, AstStatDeclareFunction* declareFunction);
-    void visit(const ScopePtr& scope, AstStatError* error);
+    ControlFlow visitBlockWithoutChildScope(const ScopePtr& scope, AstStatBlock* block);
+
+    ControlFlow visit(const ScopePtr& scope, AstStat* stat);
+    ControlFlow visit(const ScopePtr& scope, AstStatBlock* block);
+    ControlFlow visit(const ScopePtr& scope, AstStatLocal* local);
+    ControlFlow visit(const ScopePtr& scope, AstStatFor* for_);
+    ControlFlow visit(const ScopePtr& scope, AstStatForIn* forIn);
+    ControlFlow visit(const ScopePtr& scope, AstStatWhile* while_);
+    ControlFlow visit(const ScopePtr& scope, AstStatRepeat* repeat);
+    ControlFlow visit(const ScopePtr& scope, AstStatLocalFunction* function);
+    ControlFlow visit(const ScopePtr& scope, AstStatFunction* function);
+    ControlFlow visit(const ScopePtr& scope, AstStatReturn* ret);
+    ControlFlow visit(const ScopePtr& scope, AstStatAssign* assign);
+    ControlFlow visit(const ScopePtr& scope, AstStatCompoundAssign* assign);
+    ControlFlow visit(const ScopePtr& scope, AstStatIf* ifStatement);
+    ControlFlow visit(const ScopePtr& scope, AstStatTypeAlias* alias);
+    ControlFlow visit(const ScopePtr& scope, AstStatDeclareGlobal* declareGlobal);
+    ControlFlow visit(const ScopePtr& scope, AstStatDeclareClass* declareClass);
+    ControlFlow visit(const ScopePtr& scope, AstStatDeclareFunction* declareFunction);
+    ControlFlow visit(const ScopePtr& scope, AstStatError* error);
 
     InferencePack checkPack(const ScopePtr& scope, AstArray<AstExpr*> exprs, const std::vector<std::optional<TypeId>>& expectedTypes = {});
     InferencePack checkPack(const ScopePtr& scope, AstExpr* expr, const std::vector<std::optional<TypeId>>& expectedTypes = {});

Analysis/include/Luau/ConstraintSolver.h

@@ -143,6 +143,14 @@ struct ConstraintSolver
     bool block(TypeId target, NotNull<const Constraint> constraint);
     bool block(TypePackId target, NotNull<const Constraint> constraint);
 
+    /**
+     * For all constraints that are blocked on one constraint, make them block
+     * on a new constraint.
+     * @param source the constraint to copy blocks from.
+     * @param addition the constraint that other constraints should now block on.
+     */
+    void inheritBlocks(NotNull<const Constraint> source, NotNull<const Constraint> addition);
+
     // Traverse the type.  If any blocked or pending types are found, block
     // the constraint on them.
     //

Analysis/include/Luau/ControlFlow.h

@@ -0,0 +1,36 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include <memory>
+
+namespace Luau
+{
+
+struct Scope;
+using ScopePtr = std::shared_ptr<Scope>;
+
+enum class ControlFlow
+{
+    None     = 0b00001,
+    Returns  = 0b00010,
+    Throws   = 0b00100,
+    Break    = 0b01000, // Currently unused.
+    Continue = 0b10000, // Currently unused.
+};
+
+inline ControlFlow operator&(ControlFlow a, ControlFlow b)
+{
+    return ControlFlow(int(a) & int(b));
+}
+
+inline ControlFlow operator|(ControlFlow a, ControlFlow b)
+{
+    return ControlFlow(int(a) | int(b));
+}
+
+inline bool matches(ControlFlow a, ControlFlow b)
+{
+    return (a & b) != ControlFlow(0);
+}
+
+} // namespace Luau

Analysis/include/Luau/Frontend.h

@@ -89,14 +89,21 @@ struct FrontendOptions
     // order to get more precise type information)
     bool forAutocomplete = false;
 
+    bool runLintChecks = false;
+
     // If not empty, randomly shuffle the constraint set before attempting to
     // solve.  Use this value to seed the random number generator.
     std::optional<unsigned> randomizeConstraintResolutionSeed;
+
+    std::optional<LintOptions> enabledLintWarnings;
 };
 
 struct CheckResult
 {
     std::vector<TypeError> errors;
+
+    LintResult lintResult;
+
     std::vector<ModuleName> timeoutHits;
 };
 
@@ -133,8 +140,9 @@ struct Frontend
 
     CheckResult check(const ModuleName& name, std::optional<FrontendOptions> optionOverride = {}); // new shininess
 
-    LintResult lint(const ModuleName& name, std::optional<LintOptions> enabledLintWarnings = {});
-    LintResult lint(const SourceModule& module, std::optional<LintOptions> enabledLintWarnings = {});
+    // Use 'check' with 'runLintChecks' set to true in FrontendOptions (enabledLintWarnings be set there as well)
+    LintResult lint_DEPRECATED(const ModuleName& name, std::optional<LintOptions> enabledLintWarnings = {});
+    LintResult lint_DEPRECATED(const SourceModule& module, std::optional<LintOptions> enabledLintWarnings = {});
 
     bool isDirty(const ModuleName& name, bool forAutocomplete = false) const;
     void markDirty(const ModuleName& name, std::vector<ModuleName>* markedDirty = nullptr);

Analysis/include/Luau/Module.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "Luau/Error.h"
+#include "Luau/Linter.h"
 #include "Luau/FileResolver.h"
 #include "Luau/ParseOptions.h"
 #include "Luau/ParseResult.h"
@@ -88,6 +89,7 @@ struct Module
 
     std::unordered_map<Name, TypeId> declaredGlobals;
     ErrorVec errors;
+    LintResult lintResult;
     Mode mode;
     SourceCode::Type type;
     bool timeout = false;

Analysis/include/Luau/Normalize.h

@@ -19,6 +19,8 @@ using ModulePtr = std::shared_ptr<Module>;
 
 bool isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
 bool isSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
+bool isConsistentSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
+bool isConsistentSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter& ice);
 
 class TypeIds
 {
@@ -203,7 +205,7 @@ struct NormalizedFunctionType
 };
 
 // A normalized generic/free type is a union, where each option is of the form (X & T) where
-// * X is either a free type or a generic
+// * X is either a free type, a generic or a blocked type.
 // * T is a normalized type.
 struct NormalizedType;
 using NormalizedTyvars = std::unordered_map<TypeId, std::unique_ptr<NormalizedType>>;
@@ -214,7 +216,7 @@ bool isInhabited_DEPRECATED(const NormalizedType& norm);
 // * P is a union of primitive types (including singletons, classes and the error type)
 // * T is a union of table types
 // * F is a union of an intersection of function types
-// * G is a union of generic/free normalized types, intersected with a normalized type
+// * G is a union of generic/free/blocked types, intersected with a normalized type
 struct NormalizedType
 {
     // The top part of the type.

Analysis/include/Luau/Scope.h

@@ -66,6 +66,7 @@ struct Scope
 
     RefinementMap refinements;
     DenseHashMap<const Def*, TypeId> dcrRefinements{nullptr};
+    void inheritRefinements(const ScopePtr& childScope);
 
     // For mutually recursive type aliases, it's important that
     // they use the same types for the same names.

Analysis/include/Luau/Type.h

@@ -102,7 +102,7 @@ struct BlockedType
     BlockedType();
     int index;
 
-    static int nextIndex;
+    static int DEPRECATED_nextIndex;
 };
 
 struct PrimitiveType

Analysis/include/Luau/TypeInfer.h

@@ -2,14 +2,15 @@
 #pragma once
 
 #include "Luau/Anyification.h"
-#include "Luau/Predicate.h"
+#include "Luau/ControlFlow.h"
 #include "Luau/Error.h"
 #include "Luau/Module.h"
-#include "Luau/Symbol.h"
+#include "Luau/Predicate.h"
 #include "Luau/Substitution.h"
+#include "Luau/Symbol.h"
 #include "Luau/TxnLog.h"
-#include "Luau/TypePack.h"
 #include "Luau/Type.h"
+#include "Luau/TypePack.h"
 #include "Luau/Unifier.h"
 #include "Luau/UnifierSharedState.h"
 
@@ -87,28 +88,28 @@ struct TypeChecker
 
     std::vector<std::pair<Location, ScopePtr>> getScopes() const;
 
-    void check(const ScopePtr& scope, const AstStat& statement);
-    void check(const ScopePtr& scope, const AstStatBlock& statement);
-    void check(const ScopePtr& scope, const AstStatIf& statement);
-    void check(const ScopePtr& scope, const AstStatWhile& statement);
-    void check(const ScopePtr& scope, const AstStatRepeat& statement);
-    void check(const ScopePtr& scope, const AstStatReturn& return_);
-    void check(const ScopePtr& scope, const AstStatAssign& assign);
-    void check(const ScopePtr& scope, const AstStatCompoundAssign& assign);
-    void check(const ScopePtr& scope, const AstStatLocal& local);
-    void check(const ScopePtr& scope, const AstStatFor& local);
-    void check(const ScopePtr& scope, const AstStatForIn& forin);
-    void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatFunction& function);
-    void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
-    void check(const ScopePtr& scope, const AstStatTypeAlias& typealias);
-    void check(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
-    void check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
+    ControlFlow check(const ScopePtr& scope, const AstStat& statement);
+    ControlFlow check(const ScopePtr& scope, const AstStatBlock& statement);
+    ControlFlow check(const ScopePtr& scope, const AstStatIf& statement);
+    ControlFlow check(const ScopePtr& scope, const AstStatWhile& statement);
+    ControlFlow check(const ScopePtr& scope, const AstStatRepeat& statement);
+    ControlFlow check(const ScopePtr& scope, const AstStatReturn& return_);
+    ControlFlow check(const ScopePtr& scope, const AstStatAssign& assign);
+    ControlFlow check(const ScopePtr& scope, const AstStatCompoundAssign& assign);
+    ControlFlow check(const ScopePtr& scope, const AstStatLocal& local);
+    ControlFlow check(const ScopePtr& scope, const AstStatFor& local);
+    ControlFlow check(const ScopePtr& scope, const AstStatForIn& forin);
+    ControlFlow check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatFunction& function);
+    ControlFlow check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
+    ControlFlow check(const ScopePtr& scope, const AstStatTypeAlias& typealias);
+    ControlFlow check(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
+    ControlFlow check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
 
     void prototype(const ScopePtr& scope, const AstStatTypeAlias& typealias, int subLevel = 0);
     void prototype(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
 
-    void checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
-    void checkBlockWithoutRecursionCheck(const ScopePtr& scope, const AstStatBlock& statement);
+    ControlFlow checkBlock(const ScopePtr& scope, const AstStatBlock& statement);
+    ControlFlow checkBlockWithoutRecursionCheck(const ScopePtr& scope, const AstStatBlock& statement);
     void checkBlockTypeAliases(const ScopePtr& scope, std::vector<AstStat*>& sorted);
 
     WithPredicate<TypeId> checkExpr(

Analysis/include/Luau/Unifiable.h

@@ -81,6 +81,8 @@ namespace Luau::Unifiable
 
 using Name = std::string;
 
+int freshIndex();
+
 struct Free
 {
     explicit Free(TypeLevel level);

Analysis/include/Luau/Unifier.h

@@ -58,6 +58,7 @@ struct Unifier
 
     NotNull<Scope> scope; // const Scope maybe
     TxnLog log;
+    bool failure = false;
     ErrorVec errors;
     Location location;
     Variance variance = Covariant;
@@ -93,7 +94,7 @@ struct Unifier
 
     // Traverse the two types provided and block on any BlockedTypes we find.
     // Returns true if any types were blocked on.
-    bool blockOnBlockedTypes(TypeId subTy, TypeId superTy);
+    bool DEPRECATED_blockOnBlockedTypes(TypeId subTy, TypeId superTy);
 
     void tryUnifyTypeWithUnion(TypeId subTy, TypeId superTy, const UnionType* uv, bool cacheEnabled, bool isFunctionCall);
     void tryUnifyTypeWithIntersection(TypeId subTy, TypeId superTy, const IntersectionType* uv);