Bump Luau to 0.701

Author: khvzak

luau/Ast/include/Luau/Ast.h

@@ -118,6 +118,13 @@ struct AstTypeList
     AstTypePack* tailType = nullptr;
 };
 
+// Don't have Luau::Variant available, it's a bit of an overhead, but a plain struct is nice to use
+struct AstTypeOrPack
+{
+    AstType* type = nullptr;
+    AstTypePack* typePack = nullptr;
+};
+
 using AstArgumentName = std::pair<AstName, Location>; // TODO: remove and replace when we get a common struct for this pair instead of AstName
 
 extern int gAstRttiIndex;
@@ -415,11 +422,22 @@ class AstExprCall : public AstExpr
 public:
     LUAU_RTTI(AstExprCall)
 
-    AstExprCall(const Location& location, AstExpr* func, const AstArray<AstExpr*>& args, bool self, const Location& argLocation);
+    AstExprCall(
+        const Location& location,
+        AstExpr* func,
+        const AstArray<AstExpr*>& args,
+        bool self,
+        const AstArray<AstTypeOrPack>& explicitTypes,
+        const Location& argLocation
+    );
 
     void visit(AstVisitor* visitor) override;
 
     AstExpr* func;
+    // These will only be filled in specifically `t:f<<A, B>>()`.
+    // In `f<<A, B>>()`, this is parsed as `f<<A, B>>` as an expression,
+    // which is then called.
+    AstArray<AstTypeOrPack> typeArguments;
     AstArray<AstExpr*> args;
     bool self;
     Location argLocation;
@@ -642,6 +660,20 @@ class AstExprInterpString : public AstExpr
     AstArray<AstExpr*> expressions;
 };
 
+// f<<T>>
+class AstExprInstantiate : public AstExpr
+{
+public:
+    LUAU_RTTI(AstExprInstantiate)
+
+    AstExprInstantiate(const Location& location, AstExpr* expr, AstArray<AstTypeOrPack> typePack);
+
+    void visit(AstVisitor* visitor) override;
+
+    AstExpr* expr;
+    AstArray<AstTypeOrPack> typeArguments;
+};
+
 class AstStatBlock : public AstStat
 {
 public:
@@ -1071,13 +1103,6 @@ class AstType : public AstNode
     }
 };
 
-// Don't have Luau::Variant available, it's a bit of an overhead, but a plain struct is nice to use
-struct AstTypeOrPack
-{
-    AstType* type = nullptr;
-    AstTypePack* typePack = nullptr;
-};
-
 class AstTypeReference : public AstType
 {
 public:

luau/Ast/include/Luau/Cst.h

@@ -83,6 +83,18 @@ class CstExprConstantString : public CstNode
     unsigned int blockDepth;
 };
 
+// Shared between the expression and call nodes
+struct CstTypeInstantiation
+{
+    Position leftArrow1Position = {0,0};
+    Position leftArrow2Position = {0,0};
+
+    AstArray<Position> commaPositions = {};
+
+    Position rightArrow1Position = {0,0};
+    Position rightArrow2Position = {0,0};
+};
+
 class CstExprCall : public CstNode
 {
 public:
@@ -93,6 +105,7 @@ class CstExprCall : public CstNode
     std::optional<Position> openParens;
     std::optional<Position> closeParens;
     AstArray<Position> commaPositions;
+    CstTypeInstantiation* explicitTypes = nullptr;
 };
 
 class CstExprIndexExpr : public CstNode
@@ -192,6 +205,16 @@ class CstExprInterpString : public CstNode
     AstArray<Position> stringPositions;
 };
 
+class CstExprExplicitTypeInstantiation : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstExprExplicitTypeInstantiation)
+
+    explicit CstExprExplicitTypeInstantiation(CstTypeInstantiation instantiation);
+
+    CstTypeInstantiation instantiation;
+};
+
 class CstStatDo : public CstNode
 {
 public:

luau/Ast/include/Luau/Parser.h

@@ -283,7 +283,7 @@ class Parser
     // prefixexp -> NAME | '(' expr ')'
     AstExpr* parsePrefixExpr();
 
-    // primaryexp -> prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs }
+    // primaryexp -> prefixexp { `.' NAME | `[' exp `]' | TypeInstantiation | `:' NAME [TypeInstantiation] funcargs | funcargs }
     AstExpr* parsePrimaryExpr(bool asStatement);
 
     // asexp -> simpleexp [`::' Type]
@@ -310,6 +310,14 @@ class Parser
     // stringinterp ::= <INTERP_BEGIN> exp {<INTERP_MID> exp} <INTERP_END>
     AstExpr* parseInterpString();
 
+    // TypeInstantiation ::= `<' `<' [TypeList] `>' `>'
+    AstArray<AstTypeOrPack> parseTypeInstantiationExpr(
+        CstTypeInstantiation* cstNodeOut = nullptr,
+        Location* endLocationOut = nullptr
+    );
+
+    AstExpr* parseExplicitTypeInstantiationExpr(Position start, AstExpr& basedOnExpr);
+
     // Name
     std::optional<Name> parseNameOpt(const char* context = nullptr);
     Name parseName(const char* context = nullptr);

luau/Ast/src/Ast.cpp

@@ -4,6 +4,8 @@
 #include "Luau/Common.h"
 #include "Luau/StringUtils.h"
 
+LUAU_FASTFLAG(LuauExplicitTypeExpressionInstantiation)
+
 namespace Luau
 {
 
@@ -32,6 +34,19 @@ static void visitTypeList(AstVisitor* visitor, const AstTypeList& list)
         list.tailType->visit(visitor);
 }
 
+static void visitTypeOrPackArray(AstVisitor* visitor, const AstArray<AstTypeOrPack>& arrayOfTypeOrPack)
+{
+    LUAU_ASSERT(FFlag::LuauExplicitTypeExpressionInstantiation);
+
+    for (const AstTypeOrPack& param : arrayOfTypeOrPack)
+    {
+        if (param.type)
+            param.type->visit(visitor);
+        else
+            param.typePack->visit(visitor);
+    }
+}
+
 AstAttr::AstAttr(const Location& location, Type type, AstArray<AstExpr*> args)
     : AstNode(ClassIndex(), location)
     , type(type)
@@ -210,13 +225,22 @@ void AstExprVarargs::visit(AstVisitor* visitor)
     visitor->visit(this);
 }
 
-AstExprCall::AstExprCall(const Location& location, AstExpr* func, const AstArray<AstExpr*>& args, bool self, const Location& argLocation)
+AstExprCall::AstExprCall(
+    const Location& location,
+    AstExpr* func,
+    const AstArray<AstExpr*>& args,
+    bool self,
+    const AstArray<AstTypeOrPack>& explicitTypes,
+    const Location& argLocation
+)
     : AstExpr(ClassIndex(), location)
     , func(func)
+    , typeArguments(explicitTypes)
     , args(args)
     , self(self)
     , argLocation(argLocation)
 {
+    LUAU_ASSERT(FFlag::LuauExplicitTypeExpressionInstantiation || explicitTypes.size == 0);
 }
 
 void AstExprCall::visit(AstVisitor* visitor)
@@ -522,6 +546,23 @@ void AstExprInterpString::visit(AstVisitor* visitor)
     }
 }
 
+AstExprInstantiate::AstExprInstantiate(const Location& location, AstExpr* expr, AstArray<AstTypeOrPack> types)
+    : AstExpr(ClassIndex(), location)
+    , expr(expr)
+    , typeArguments(types)
+{
+    LUAU_ASSERT(FFlag::LuauExplicitTypeExpressionInstantiation);
+}
+
+void AstExprInstantiate::visit(AstVisitor* visitor)
+{
+    if (visitor->visit(this))
+    {
+        visitTypeOrPackArray(visitor, typeArguments);
+    }
+}
+
+
 void AstExprError::visit(AstVisitor* visitor)
 {
     if (visitor->visit(this))
@@ -1056,12 +1097,19 @@ void AstTypeReference::visit(AstVisitor* visitor)
 {
     if (visitor->visit(this))
     {
-        for (const AstTypeOrPack& param : parameters)
+        if (FFlag::LuauExplicitTypeExpressionInstantiation)
+        {
+            visitTypeOrPackArray(visitor, parameters);
+        }
+        else
         {
-            if (param.type)
-                param.type->visit(visitor);
-            else
-                param.typePack->visit(visitor);
+            for (const AstTypeOrPack& param : parameters)
+            {
+                if (param.type)
+                    param.type->visit(visitor);
+                else
+                    param.typePack->visit(visitor);
+            }
         }
     }
 }

luau/Ast/src/Cst.cpp

@@ -76,6 +76,12 @@ CstExprInterpString::CstExprInterpString(AstArray<AstArray<char>> sourceStrings,
 {
 }
 
+CstExprExplicitTypeInstantiation::CstExprExplicitTypeInstantiation(CstTypeInstantiation instantiation)
+    : CstNode(CstClassIndex())
+    , instantiation(instantiation)
+{
+}
+
 CstStatDo::CstStatDo(Position endPosition)
     : CstNode(CstClassIndex())
     , endPosition(endPosition)