Sync to upstream/release/539 (#625)

.gitignore

@@ -8,4 +8,6 @@
 /default.prof*
 /fuzz-*
 /luau
+/luau-tests
+/luau-analyze
 __pycache__

Analysis/include/Luau/ApplyTypeFunction.h

@@ -0,0 +1,32 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Substitution.h"
+#include "Luau/TxnLog.h"
+#include "Luau/TypeVar.h"
+
+namespace Luau
+{
+
+// A substitution which replaces the type parameters of a type function by arguments
+struct ApplyTypeFunction : Substitution
+{
+    ApplyTypeFunction(TypeArena* arena)
+        : Substitution(TxnLog::empty(), arena)
+        , encounteredForwardedType(false)
+    {
+    }
+
+    // Never set under deferred constraint resolution.
+    bool encounteredForwardedType;
+    std::unordered_map<TypeId, TypeId> typeArguments;
+    std::unordered_map<TypePackId, TypePackId> typePackArguments;
+    bool ignoreChildren(TypeId ty) override;
+    bool ignoreChildren(TypePackId tp) override;
+    bool isDirty(TypeId ty) override;
+    bool isDirty(TypePackId tp) override;
+    TypeId clean(TypeId ty) override;
+    TypePackId clean(TypePackId tp) override;
+};
+
+} // namespace Luau

Analysis/include/Luau/Constraint.h

@@ -4,6 +4,7 @@
 #include "Luau/Ast.h" // Used for some of the enumerations
 #include "Luau/NotNull.h"
 #include "Luau/Variant.h"
+#include "Luau/TypeVar.h"
 
 #include <string>
 #include <memory>
@@ -71,8 +72,15 @@ struct NameConstraint
     std::string name;
 };
 
+// target ~ inst target
+struct TypeAliasExpansionConstraint
+{
+    // Must be a PendingExpansionTypeVar.
+    TypeId target;
+};
+
 using ConstraintV = Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint,
-    BinaryConstraint, NameConstraint>;
+    BinaryConstraint, NameConstraint, TypeAliasExpansionConstraint>;
 using ConstraintPtr = std::unique_ptr<struct Constraint>;
 
 struct Constraint

Analysis/include/Luau/ConstraintGraphBuilder.h

@@ -42,6 +42,8 @@ struct ConstraintGraphBuilder
     DenseHashMap<const AstType*, TypeId> astResolvedTypes{nullptr};
     // Type packs resolved from type annotations. Analogous to astTypePacks.
     DenseHashMap<const AstTypePack*, TypePackId> astResolvedTypePacks{nullptr};
+    // Defining scopes for AST nodes.
+    DenseHashMap<const AstStatTypeAlias*, ScopePtr> astTypeAliasDefiningScopes{nullptr};
 
     int recursionCount = 0;
 
@@ -107,6 +109,9 @@ struct ConstraintGraphBuilder
     void visit(const ScopePtr& scope, AstStatAssign* 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);
 
     TypePackId checkExprList(const ScopePtr& scope, const AstArray<AstExpr*>& exprs);
 
@@ -153,9 +158,10 @@ struct ConstraintGraphBuilder
      * Resolves a type from its AST annotation.
      * @param scope the scope that the type annotation appears within.
      * @param ty the AST annotation to resolve.
+     * @param topLevel whether the annotation is a "top-level" annotation.
      * @return the type of the AST annotation.
      **/
-    TypeId resolveType(const ScopePtr& scope, AstType* ty);
+    TypeId resolveType(const ScopePtr& scope, AstType* ty, bool topLevel = false);
 
     /**
      * Resolves a type pack from its AST annotation.

Analysis/include/Luau/ConstraintSolver.h

@@ -17,16 +17,36 @@ namespace Luau
 // never dereference this pointer.
 using BlockedConstraintId = const void*;
 
+struct InstantiationSignature
+{
+    TypeFun fn;
+    std::vector<TypeId> arguments;
+    std::vector<TypePackId> packArguments;
+
+    bool operator==(const InstantiationSignature& rhs) const;
+    bool operator!=(const InstantiationSignature& rhs) const
+    {
+        return !((*this) == rhs);
+    }
+};
+
+struct HashInstantiationSignature
+{
+    size_t operator()(const InstantiationSignature& signature) const;
+};
+
 struct ConstraintSolver
 {
     TypeArena* arena;
     InternalErrorReporter iceReporter;
-    // The entire set of constraints that the solver is trying to resolve. It
-    // is important to not add elements to this vector, lest the underlying
-    // storage that we retain pointers to be mutated underneath us.
-    const std::vector<NotNull<Constraint>> constraints;
+    // The entire set of constraints that the solver is trying to resolve.
+    std::vector<NotNull<Constraint>> constraints;
     NotNull<Scope> rootScope;
 
+    // Constraints that the solver has generated, rather than sourcing from the
+    // scope tree.
+    std::vector<std::unique_ptr<Constraint>> solverConstraints;
+
     // This includes every constraint that has not been fully solved.
     // A constraint can be both blocked and unsolved, for instance.
     std::vector<NotNull<const Constraint>> unsolvedConstraints;
@@ -37,6 +57,8 @@ struct ConstraintSolver
     std::unordered_map<NotNull<const Constraint>, size_t> blockedConstraints;
     // A mapping of type/pack pointers to the constraints they block.
     std::unordered_map<BlockedConstraintId, std::vector<NotNull<const Constraint>>> blocked;
+    // Memoized instantiations of type aliases.
+    DenseHashMap<InstantiationSignature, TypeId, HashInstantiationSignature> instantiatedAliases{{}};
 
     ConstraintSolverLogger logger;
 
@@ -62,6 +84,7 @@ struct ConstraintSolver
     bool tryDispatch(const UnaryConstraint& c, NotNull<const Constraint> constraint, bool force);
     bool tryDispatch(const BinaryConstraint& c, NotNull<const Constraint> constraint, bool force);
     bool tryDispatch(const NameConstraint& c, NotNull<const Constraint> constraint);
+    bool tryDispatch(const TypeAliasExpansionConstraint& c, NotNull<const Constraint> constraint);
 
     void block(NotNull<const Constraint> target, NotNull<const Constraint> constraint);
     /**
@@ -102,6 +125,11 @@ struct ConstraintSolver
      */
     void unify(TypePackId subPack, TypePackId superPack);
 
+    /** Pushes a new solver constraint to the solver.
+     * @param cv the body of the constraint.
+     **/
+    void pushConstraint(ConstraintV cv);
+
 private:
     /**
      * Marks a constraint as being blocked on a type or type pack. The constraint

Analysis/include/Luau/Frontend.h

@@ -152,6 +152,8 @@ struct Frontend
     void registerBuiltinDefinition(const std::string& name, std::function<void(TypeChecker&, ScopePtr)>);
     void applyBuiltinDefinitionToEnvironment(const std::string& environmentName, const std::string& definitionName);
 
+    LoadDefinitionFileResult loadDefinitionFile(std::string_view source, const std::string& packageName);
+
     NotNull<Scope> getGlobalScope();
 
 private:
@@ -169,7 +171,7 @@ struct Frontend
     std::unordered_map<std::string, ScopePtr> environments;
     std::unordered_map<std::string, std::function<void(TypeChecker&, ScopePtr)>> builtinDefinitions;
 
-    std::unique_ptr<Scope> globalScope;
+    ScopePtr globalScope;
 
 public:
     FileResolver* fileResolver;
@@ -180,6 +182,7 @@ struct Frontend
     ConfigResolver* configResolver;
     FrontendOptions options;
     InternalErrorReporter iceHandler;
+    TypeArena globalTypes;
     TypeArena arenaForAutocomplete;
 
     std::unordered_map<ModuleName, SourceNode> sourceNodes;