Bump Luau to 0.666

Author: khvzak

luau/Ast/include/Luau/Ast.h

@@ -1127,6 +1127,16 @@ class AstTypeTypeof : public AstType
     AstExpr* expr;
 };
 
+class AstTypeOptional : public AstType
+{
+public:
+    LUAU_RTTI(AstTypeOptional)
+
+    AstTypeOptional(const Location& location);
+
+    void visit(AstVisitor* visitor) override;
+};
+
 class AstTypeUnion : public AstType
 {
 public:
@@ -1488,6 +1498,10 @@ class AstVisitor
     {
         return visit(static_cast<AstType*>(node));
     }
+    virtual bool visit(class AstTypeOptional* node)
+    {
+        return visit(static_cast<AstType*>(node));
+    }
     virtual bool visit(class AstTypeUnion* node)
     {
         return visit(static_cast<AstType*>(node));

luau/Ast/include/Luau/Cst.h

@@ -105,6 +105,20 @@ class CstExprIndexExpr : public CstNode
     Position closeBracketPosition;
 };
 
+class CstExprFunction : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstExprFunction)
+
+    CstExprFunction();
+
+    Position openGenericsPosition{0,0};
+    AstArray<Position> genericsCommaPositions;
+    Position closeGenericsPosition{0,0};
+    AstArray<Position> argsCommaPositions;
+    Position returnSpecifierPosition{0,0};
+};
+
 class CstExprTable : public CstNode
 {
 public:
@@ -311,6 +325,17 @@ class CstStatTypeAlias : public CstNode
     Position equalsPosition;
 };
 
+class CstStatTypeFunction : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstStatTypeFunction)
+
+    CstStatTypeFunction(Position typeKeywordPosition, Position functionKeywordPosition);
+
+    Position typeKeywordPosition;
+    Position functionKeywordPosition;
+};
+
 class CstTypeReference : public CstNode
 {
 public:
@@ -359,6 +384,32 @@ class CstTypeTable : public CstNode
     bool isArray = false;
 };
 
+class CstTypeFunction : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstTypeFunction)
+
+    CstTypeFunction(
+        Position openGenericsPosition,
+        AstArray<Position> genericsCommaPositions,
+        Position closeGenericsPosition,
+        Position openArgsPosition,
+        AstArray<std::optional<Position>> argumentNameColonPositions,
+        AstArray<Position> argumentsCommaPositions,
+        Position closeArgsPosition,
+        Position returnArrowPosition
+    );
+
+    Position openGenericsPosition;
+    AstArray<Position> genericsCommaPositions;
+    Position closeGenericsPosition;
+    Position openArgsPosition;
+    AstArray<std::optional<Position>> argumentNameColonPositions;
+    AstArray<Position> argumentsCommaPositions;
+    Position closeArgsPosition;
+    Position returnArrowPosition;
+};
+
 class CstTypeTypeof : public CstNode
 {
 public:
@@ -382,4 +433,26 @@ class CstTypeSingletonString : public CstNode
     unsigned int blockDepth;
 };
 
+class CstTypePackExplicit : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstTypePackExplicit)
+
+    CstTypePackExplicit(Position openParenthesesPosition, Position closeParenthesesPosition, AstArray<Position> commaPositions);
+
+    Position openParenthesesPosition;
+    Position closeParenthesesPosition;
+    AstArray<Position> commaPositions;
+};
+
+class CstTypePackGeneric : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstTypePackGeneric)
+
+    explicit CstTypePackGeneric(Position ellipsisPosition);
+
+    Position ellipsisPosition;
+};
+
 } // namespace Luau

luau/Ast/include/Luau/Parser.h

@@ -155,7 +155,7 @@ class Parser
     AstStat* parseTypeAlias(const Location& start, bool exported, Position typeKeywordPosition);
 
     // type function Name ... end
-    AstStat* parseTypeFunction(const Location& start, bool exported);
+    AstStat* parseTypeFunction(const Location& start, bool exported, Position typeKeywordPosition);
 
     AstDeclaredClassProp parseDeclaredClassMethod();
 
@@ -192,7 +192,8 @@ class Parser
     std::tuple<bool, Location, AstTypePack*> parseBindingList(
         TempVector<Binding>& result,
         bool allowDot3 = false,
-        TempVector<Position>* commaPositions = nullptr
+        AstArray<Position>* commaPositions = nullptr,
+        std::optional<Position> initialCommaPosition = std::nullopt
     );
 
     AstType* parseOptionalType();
@@ -209,9 +210,14 @@ class Parser
     //      |   `(' [TypeList] `)' `->` ReturnType
 
     // Returns the variadic annotation, if it exists.
-    AstTypePack* parseTypeList(TempVector<AstType*>& result, TempVector<std::optional<AstArgumentName>>& resultNames);
+    AstTypePack* parseTypeList(
+        TempVector<AstType*>& result,
+        TempVector<std::optional<AstArgumentName>>& resultNames,
+        TempVector<Position>* commaPositions = nullptr,
+        TempVector<std::optional<Position>>* nameColonPositions = nullptr
+    );
 
-    std::optional<AstTypeList> parseOptionalReturnType();
+    std::optional<AstTypeList> parseOptionalReturnType(Position* returnSpecifierPosition = nullptr);
     std::pair<Location, AstTypeList> parseReturnType();
 
     struct TableIndexerResult
@@ -305,7 +311,7 @@ class Parser
     std::pair<AstArray<AstGenericType*>, AstArray<AstGenericTypePack*>> parseGenericTypeList(
         bool withDefaultValues,
         Position* openPosition = nullptr,
-        TempVector<Position>* commaPositions = nullptr,
+        AstArray<Position>* commaPositions = nullptr,
         Position* closePosition = nullptr
     );
 
@@ -491,6 +497,7 @@ class Parser
     std::vector<AstGenericTypePack*> scratchGenericTypePacks;
     std::vector<std::optional<AstArgumentName>> scratchOptArgName;
     std::vector<Position> scratchPosition;
+    std::vector<std::optional<Position>> scratchOptPosition;
     std::string scratchData;
 
     CstNodeMap cstNodeMap;

luau/Ast/src/Ast.cpp

@@ -1069,6 +1069,16 @@ void AstTypeTypeof::visit(AstVisitor* visitor)
         expr->visit(visitor);
 }
 
+AstTypeOptional::AstTypeOptional(const Location& location)
+    : AstType(ClassIndex(), location)
+{
+}
+
+void AstTypeOptional::visit(AstVisitor* visitor)
+{
+    visitor->visit(this);
+}
+
 AstTypeUnion::AstTypeUnion(const Location& location, const AstArray<AstType*>& types)
     : AstType(ClassIndex(), location)
     , types(types)

luau/Ast/src/Cst.cpp

@@ -38,6 +38,10 @@ CstExprIndexExpr::CstExprIndexExpr(Position openBracketPosition, Position closeB
 {
 }
 
+CstExprFunction::CstExprFunction() : CstNode(CstClassIndex())
+{
+}
+
 CstExprTable::CstExprTable(const AstArray<Item>& items)
     : CstNode(CstClassIndex())
     , items(items)
@@ -160,6 +164,13 @@ CstStatTypeAlias::CstStatTypeAlias(
 {
 }
 
+CstStatTypeFunction::CstStatTypeFunction(Position typeKeywordPosition, Position functionKeywordPosition)
+    : CstNode(CstClassIndex())
+    , typeKeywordPosition(typeKeywordPosition)
+    , functionKeywordPosition(functionKeywordPosition)
+{
+}
+
 CstTypeReference::CstTypeReference(
     std::optional<Position> prefixPointPosition,
     Position openParametersPosition,
@@ -181,6 +192,28 @@ CstTypeTable::CstTypeTable(AstArray<Item> items, bool isArray)
 {
 }
 
+CstTypeFunction::CstTypeFunction(
+    Position openGenericsPosition,
+    AstArray<Position> genericsCommaPositions,
+    Position closeGenericsPosition,
+    Position openArgsPosition,
+    AstArray<std::optional<Position>> argumentNameColonPositions,
+    AstArray<Position> argumentsCommaPositions,
+    Position closeArgsPosition,
+    Position returnArrowPosition
+)
+    : CstNode(CstClassIndex())
+    , openGenericsPosition(openGenericsPosition)
+    , genericsCommaPositions(genericsCommaPositions)
+    , closeGenericsPosition(closeGenericsPosition)
+    , openArgsPosition(openArgsPosition)
+    , argumentNameColonPositions(argumentNameColonPositions)
+    , argumentsCommaPositions(argumentsCommaPositions)
+    , closeArgsPosition(closeArgsPosition)
+    , returnArrowPosition(returnArrowPosition)
+{
+}
+
 CstTypeTypeof::CstTypeTypeof(Position openPosition, Position closePosition)
     : CstNode(CstClassIndex())
     , openPosition(openPosition)
@@ -197,4 +230,18 @@ CstTypeSingletonString::CstTypeSingletonString(AstArray<char> sourceString, CstE
     LUAU_ASSERT(quoteStyle != CstExprConstantString::QuotedInterp);
 }
 
+CstTypePackExplicit::CstTypePackExplicit(Position openParenthesesPosition, Position closeParenthesesPosition, AstArray<Position> commaPositions)
+    : CstNode(CstClassIndex())
+    , openParenthesesPosition(openParenthesesPosition)
+    , closeParenthesesPosition(closeParenthesesPosition)
+    , commaPositions(commaPositions)
+{
+}
+
+CstTypePackGeneric::CstTypePackGeneric(Position ellipsisPosition)
+    : CstNode(CstClassIndex())
+    , ellipsisPosition(ellipsisPosition)
+{
+}
+
 } // namespace Luau

luau/Ast/src/Lexer.cpp

@@ -8,9 +8,6 @@
 
 #include <limits.h>
 
-LUAU_FASTFLAGVARIABLE(LexerResumesFromPosition2)
-LUAU_FASTFLAGVARIABLE(LexerFixInterpStringStart)
-
 namespace Luau
 {
 
@@ -342,12 +339,9 @@ Lexer::Lexer(const char* buffer, size_t bufferSize, AstNameTable& names, Positio
     : buffer(buffer)
     , bufferSize(bufferSize)
     , offset(0)
-    , line(FFlag::LexerResumesFromPosition2 ? startPosition.line : 0)
-    , lineOffset(FFlag::LexerResumesFromPosition2 ? 0u - startPosition.column : 0)
-    , lexeme(
-          (FFlag::LexerResumesFromPosition2 ? Location(Position(startPosition.line, startPosition.column), 0) : Location(Position(0, 0), 0)),
-          Lexeme::Eof
-      )
+    , line(startPosition.line)
+    , lineOffset(0u - startPosition.column)
+    , lexeme((Location(Position(startPosition.line, startPosition.column), 0)), Lexeme::Eof)
     , names(names)
     , skipComments(false)
     , readNames(true)
@@ -793,7 +787,7 @@ Lexeme Lexer::readNext()
             return Lexeme(Location(start, 1), '}');
         }
 
-        return readInterpolatedStringSection(FFlag::LexerFixInterpStringStart ? start : position(), Lexeme::InterpStringMid, Lexeme::InterpStringEnd);
+        return readInterpolatedStringSection(start, Lexeme::InterpStringMid, Lexeme::InterpStringEnd);
     }
 
     case '=':