Sync to upstream/release/546 (#681)

Analysis/include/Luau/Constraint.h

@@ -90,18 +90,49 @@ struct TypeAliasExpansionConstraint
     TypeId target;
 };
 
-using ConstraintPtr = std::unique_ptr<struct Constraint>;
-
 struct FunctionCallConstraint
 {
-    std::vector<NotNull<const Constraint>> innerConstraints;
+    std::vector<NotNull<const struct Constraint>> innerConstraints;
     TypeId fn;
     TypePackId result;
     class AstExprCall* astFragment;
 };
 
-using ConstraintV = Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint,
-    BinaryConstraint, IterableConstraint, NameConstraint, TypeAliasExpansionConstraint, FunctionCallConstraint>;
+// result ~ prim ExpectedType SomeSingletonType MultitonType
+//
+// If ExpectedType is potentially a singleton (an actual singleton or a union
+// that contains a singleton), then result ~ SomeSingletonType
+//
+// else result ~ MultitonType
+struct PrimitiveTypeConstraint
+{
+    TypeId resultType;
+    TypeId expectedType;
+    TypeId singletonType;
+    TypeId multitonType;
+};
+
+// result ~ hasProp type "prop_name"
+//
+// If the subject is a table, bind the result to the named prop.  If the table
+// has an indexer, bind it to the index result type. If the subject is a union,
+// bind the result to the union of its constituents' properties.
+//
+// It would be nice to get rid of this constraint and someday replace it with
+//
+// T <: {p: X}
+//
+// Where {} describes an inexact shape type.
+struct HasPropConstraint
+{
+    TypeId resultType;
+    TypeId subjectType;
+    std::string prop;
+};
+
+using ConstraintV =
+    Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint, BinaryConstraint,
+        IterableConstraint, NameConstraint, TypeAliasExpansionConstraint, FunctionCallConstraint, PrimitiveTypeConstraint, HasPropConstraint>;
 
 struct Constraint
 {
@@ -117,6 +148,8 @@ struct Constraint
     std::vector<NotNull<Constraint>> dependencies;
 };
 
+using ConstraintPtr = std::unique_ptr<Constraint>;
+
 inline Constraint& asMutable(const Constraint& c)
 {
     return const_cast<Constraint&>(c);

Analysis/include/Luau/ConstraintGraphBuilder.h

@@ -125,23 +125,25 @@ struct ConstraintGraphBuilder
     void visit(const ScopePtr& scope, AstStatDeclareClass* declareClass);
     void visit(const ScopePtr& scope, AstStatDeclareFunction* declareFunction);
 
-    TypePackId checkPack(const ScopePtr& scope, AstArray<AstExpr*> exprs);
-    TypePackId checkPack(const ScopePtr& scope, AstExpr* expr);
+    TypePackId checkPack(const ScopePtr& scope, AstArray<AstExpr*> exprs, const std::vector<TypeId>& expectedTypes = {});
+    TypePackId checkPack(const ScopePtr& scope, AstExpr* expr, const std::vector<TypeId>& expectedTypes = {});
 
     /**
      * Checks an expression that is expected to evaluate to one type.
      * @param scope the scope the expression is contained within.
      * @param expr the expression to check.
+     * @param expectedType the type of the expression that is expected from its
+     *      surrounding context.  Used to implement bidirectional type checking.
      * @return the type of the expression.
      */
-    TypeId check(const ScopePtr& scope, AstExpr* expr);
+    TypeId check(const ScopePtr& scope, AstExpr* expr, std::optional<TypeId> expectedType = {});
 
-    TypeId checkExprTable(const ScopePtr& scope, AstExprTable* expr);
+    TypeId check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
     TypeId check(const ScopePtr& scope, AstExprIndexName* indexName);
     TypeId check(const ScopePtr& scope, AstExprIndexExpr* indexExpr);
     TypeId check(const ScopePtr& scope, AstExprUnary* unary);
     TypeId check(const ScopePtr& scope, AstExprBinary* binary);
-    TypeId check(const ScopePtr& scope, AstExprIfElse* ifElse);
+    TypeId check(const ScopePtr& scope, AstExprIfElse* ifElse, std::optional<TypeId> expectedType);
     TypeId check(const ScopePtr& scope, AstExprTypeAssertion* typeAssert);
 
     struct FunctionSignature

Analysis/include/Luau/ConstraintSolver.h

@@ -100,6 +100,8 @@ struct ConstraintSolver
     bool tryDispatch(const NameConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const TypeAliasExpansionConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const FunctionCallConstraint& c, NotNull<const Constraint> constraint);
+    bool tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint);
+    bool tryDispatch(const HasPropConstraint& c, NotNull<const Constraint> constraint);
 
     // for a, ... in some_table do
     bool tryDispatchIterableTable(TypeId iteratorTy, const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);
@@ -116,6 +118,16 @@ struct ConstraintSolver
     bool block(TypeId target, NotNull<const Constraint> constraint);
     bool block(TypePackId target, NotNull<const Constraint> constraint);
 
+    // Traverse the type.  If any blocked or pending typevars are found, block
+    // the constraint on them.
+    //
+    // Returns false if a type blocks the constraint.
+    //
+    // FIXME: This use of a boolean for the return result is an appalling
+    // interface.
+    bool recursiveBlock(TypeId target, NotNull<const Constraint> constraint);
+    bool recursiveBlock(TypePackId target, NotNull<const Constraint> constraint);
+
     void unblock(NotNull<const Constraint> progressed);
     void unblock(TypeId progressed);
     void unblock(TypePackId progressed);

Analysis/include/Luau/Normalize.h

@@ -17,8 +17,8 @@ struct SingletonTypes;
 
 using ModulePtr = std::shared_ptr<Module>;
 
-bool isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope, NotNull<SingletonTypes> singletonTypes, InternalErrorReporter& ice);
-bool isSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope, NotNull<SingletonTypes> singletonTypes, InternalErrorReporter& ice);
+bool isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope, NotNull<SingletonTypes> singletonTypes, InternalErrorReporter& ice, bool anyIsTop = true);
+bool isSubtype(TypePackId subTy, TypePackId superTy, NotNull<Scope> scope, NotNull<SingletonTypes> singletonTypes, InternalErrorReporter& ice, bool anyIsTop = true);
 
 std::pair<TypeId, bool> normalize(
     TypeId ty, NotNull<Scope> scope, TypeArena& arena, NotNull<SingletonTypes> singletonTypes, InternalErrorReporter& ice);

Analysis/include/Luau/RequireTracer.h

@@ -6,6 +6,7 @@
 #include "Luau/Location.h"
 
 #include <string>
+#include <vector>
 
 namespace Luau
 {