Explicit type instantiations (f<<T>>) (#1980)

This adds in support for [Explicit type parameter
instantiation](https://rfcs.luau.org/explicit-type-parameter-instantiation.html).

This PR is still a work in progress, but some important notes:

1. Metatables with `__call` are **not** supported. While `t<<A>>()` is
obvious what it should do with `__call`, it's not obvious what `t<<A>>`
on its own would be.
2. Intersection types are not supported at the moment either.

Both of these are possible to bring later.

Author: Kampfkarren

Analysis/include/Luau/AstUtils.h

@@ -9,8 +9,8 @@
 namespace Luau
 {
 
-// Search through the expression 'expr' for types that are known to represent
-// uniquely held references. Append these types to 'uniqueTypes'.
+// Search through the expression 'expr' for typeArguments that are known to represent
+// uniquely held references. Append these typeArguments to 'uniqueTypes'.
 void findUniqueTypes(NotNull<DenseHashSet<TypeId>> uniqueTypes, AstExpr* expr, NotNull<const DenseHashMap<const AstExpr*, TypeId>> astTypes);
 
 void findUniqueTypes(

Analysis/include/Luau/Constraint.h

@@ -99,6 +99,9 @@ struct FunctionCallConstraint
     class AstExprCall* callSite = nullptr;
     std::vector<std::optional<TypeId>> discriminantTypes;
 
+    std::vector<TypeId> typeArguments;
+    std::vector<TypePackId> typePackArguments;
+
     // When we dispatch this constraint, we update the key at this map to record
     // the overload that we selected.
     DenseHashMap<const AstNode*, TypeId>* astOverloadResolvedTypes = nullptr;
@@ -292,6 +295,16 @@ struct PushFunctionTypeConstraint
     bool isSelf;
 };
 
+// Binds the function to a set of explicitly specified types,
+// for f<<T>>.
+struct TypeInstantiationConstraint
+{
+    TypeId functionType;
+    TypeId placeholderType;
+    std::vector<TypeId> typeArguments;
+    std::vector<TypePackId> typePackArguments;
+};
+
 struct PushTypeConstraint
 {
     TypeId expectedType;
@@ -321,7 +334,8 @@ using ConstraintV = Variant<
     EqualityConstraint,
     SimplifyConstraint,
     PushFunctionTypeConstraint,
-    PushTypeConstraint>;
+    PushTypeConstraint,
+    TypeInstantiationConstraint>;
 
 struct Constraint
 {

Analysis/include/Luau/ConstraintGenerator.h

@@ -333,6 +333,7 @@ struct ConstraintGenerator
     Inference check(const ScopePtr& scope, AstExprIfElse* ifElse, std::optional<TypeId> expectedType);
     Inference check(const ScopePtr& scope, AstExprTypeAssertion* typeAssert);
     Inference check(const ScopePtr& scope, AstExprInterpString* interpString);
+    Inference check(const ScopePtr& scope, AstExprInstantiate* explicitTypeInstantiation);
     Inference check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
     std::tuple<TypeId, TypeId, RefinementId> checkBinary(
         const ScopePtr& scope,
@@ -482,6 +483,8 @@ struct ConstraintGenerator
 
     void fillInInferredBindings(const ScopePtr& globalScope, AstStatBlock* block);
 
+    std::pair<std::vector<TypeId>, std::vector<TypePackId>> resolveTypeArguments(const ScopePtr& scope, const AstArray<AstTypeOrPack>& typeArguments);
+
     /** Given a function type annotation, return a vector describing the expected types of the calls to the function
      *  For example, calling a function with annotation ((number) -> string & ((string) -> number))
      *  yields a vector of size 1, with value: [number | string]

Analysis/include/Luau/ConstraintSolver.h

@@ -241,7 +241,7 @@ struct ConstraintSolver
     bool tryDispatch(const FunctionCheckConstraint& c, NotNull<const Constraint> constraint, bool force);
     bool tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const HasPropConstraint& c, NotNull<const Constraint> constraint);
-
+    bool tryDispatch(const TypeInstantiationConstraint& c, NotNull<const Constraint> constraint);
 
     bool tryDispatchHasIndexer(
         int& recursionDepth,
@@ -470,6 +470,14 @@ struct ConstraintSolver
 
     TypeId simplifyUnion(NotNull<Scope> scope, Location location, TypeId left, TypeId right);
 
+    TypeId instantiateFunctionType(
+        TypeId functionTypeId,
+        const std::vector<TypeId>& typeArguments,
+        const std::vector<TypePackId>& typePackArguments,
+        NotNull<Scope> scope,
+        const Location& location
+    );
+
     TypePackId anyifyModuleReturnTypePackGenerics(TypePackId tp);
 
     void throwTimeLimitError() const;

Analysis/include/Luau/DataFlowGraph.h

@@ -189,6 +189,7 @@ struct DataFlowGraphBuilder
     DataFlowResult visitExpr(AstExprTypeAssertion* t);
     DataFlowResult visitExpr(AstExprIfElse* i);
     DataFlowResult visitExpr(AstExprInterpString* i);
+    DataFlowResult visitExpr(AstExprInstantiate* i);
     DataFlowResult visitExpr(AstExprError* error);
 
     void visitLValue(AstExpr* e, DefId incomingDef);

Analysis/include/Luau/Error.h

@@ -535,6 +535,36 @@ struct GenericBoundsMismatch
     bool operator==(const GenericBoundsMismatch& rhs) const;
 };
 
+// Used `f<<T>>` where f is not a function
+struct InstantiateGenericsOnNonFunction
+{
+    enum class InterestingEdgeCase
+    {
+        None,
+        MetatableCall,
+        Intersection,
+    };
+
+    InterestingEdgeCase interestingEdgeCase;
+
+    bool operator==(const InstantiateGenericsOnNonFunction&) const;
+};
+
+// Provided too many generics inside `f<<T>>`
+struct TypeInstantiationCountMismatch
+{
+    std::optional<std::string> functionName;
+    TypeId functionType;
+
+    size_t providedTypes = 0;
+    size_t maximumTypes = 0;
+
+    size_t providedTypePacks = 0;
+    size_t maximumTypePacks = 0;
+
+    bool operator==(const TypeInstantiationCountMismatch&) const;
+};
+
 // Error when referencing a type function without providing explicit generics.
 //
 //  type function create_table_with_key()
@@ -609,8 +639,9 @@ using TypeErrorData = Variant<
     MultipleNonviableOverloads,
     RecursiveRestraintViolation,
     GenericBoundsMismatch,
-    UnappliedTypeFunction>;
-
+    UnappliedTypeFunction,
+    InstantiateGenericsOnNonFunction,
+    TypeInstantiationCountMismatch>;
 
 struct TypeErrorSummary
 {

Analysis/include/Luau/ToString.h

@@ -140,6 +140,7 @@ 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 std::vector<TypeId>& types);
+std::string dump(const std::vector<TypePackId>& types);
 std::string dump(DenseHashMap<TypeId, TypeId>& types);
 std::string dump(DenseHashMap<TypePackId, TypePackId>& types);
 
@@ -163,4 +164,5 @@ inline std::string toString(const TypeOrPack& tyOrTp)
 std::string dump(const TypeOrPack& tyOrTp);
 
 std::string toStringVector(const std::vector<TypeId>& types, ToStringOptions& opts);
+std::string toStringVector(const std::vector<TypePackId>& typePacks, ToStringOptions& opts);
 } // namespace Luau

Analysis/include/Luau/TypeChecker2.h

@@ -173,6 +173,7 @@ struct TypeChecker2
     void visit(AstExprTypeAssertion* expr);
     void visit(AstExprIfElse* expr);
     void visit(AstExprInterpString* interpString);
+    void visit(AstExprInstantiate* explicitTypeInstantiation);
     void visit(AstExprError* expr);
     TypeId flattenPack(TypePackId pack);
     void visitGenerics(AstArray<AstGenericType*> generics, AstArray<AstGenericTypePack*> genericPacks);
@@ -233,6 +234,8 @@ struct TypeChecker2
 
     void suggestAnnotations(AstExprFunction* expr, TypeId ty);
 
+    void checkTypeInstantiation(AstExpr* baseFunctionExpr, TypeId fnType, const Location& location, const AstArray<AstTypeOrPack>& typeArguments);
+
     void diagnoseMissingTableKey(UnknownProperty* utk, TypeErrorData& data) const;
     bool isErrorSuppressing(Location loc, TypeId ty);
     bool isErrorSuppressing(Location loc1, TypeId ty1, Location loc2, TypeId ty2);

Analysis/include/Luau/TypeInfer.h

@@ -134,6 +134,7 @@ struct TypeChecker
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprError& expr);
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprIfElse& expr, std::optional<TypeId> expectedType = std::nullopt);
     WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprInterpString& expr);
+    WithPredicate<TypeId> checkExpr(const ScopePtr& scope, const AstExprInstantiate& expr);
 
     TypeId checkExprTable(
         const ScopePtr& scope,
@@ -227,6 +228,14 @@ struct TypeChecker
         const std::vector<std::optional<TypeId>>& expectedTypes = {}
     );
 
+    TypeId instantiateTypeParameters(
+        const ScopePtr& scope,
+        TypeId baseType,
+        const AstArray<AstTypeOrPack>& explicitTypes,
+        const AstExpr* functionExpr,
+        const Location& location
+    );
+
     static std::optional<AstExpr*> matchRequire(const AstExprCall& call);
     TypeId checkRequire(const ScopePtr& scope, const ModuleInfo& moduleInfo, const Location& location);