luau-lang · AmaranthineCodices · Sep 1, 2023 · Sep 1, 2022 · Sep 1, 2022 · Sep 8, 2022
diff --git a/Analysis/include/Luau/Metamethods.h b/Analysis/include/Luau/Metamethods.h
@@ -19,6 +19,7 @@ static const std::unordered_map<AstExprBinary::Op, const char*> kBinaryOpMetamet
     {AstExprBinary::Op::Sub, "__sub"},
     {AstExprBinary::Op::Mul, "__mul"},
     {AstExprBinary::Op::Div, "__div"},
+    {AstExprBinary::Op::FloorDiv, "__idiv"},
     {AstExprBinary::Op::Pow, "__pow"},
     {AstExprBinary::Op::Mod, "__mod"},
     {AstExprBinary::Op::Concat, "__concat"},

diff --git a/Analysis/include/Luau/Subtyping.h b/Analysis/include/Luau/Subtyping.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "Luau/Type.h"
+#include "Luau/TypePack.h"
 #include "Luau/UnifierSharedState.h"
 
 #include <vector>
@@ -14,8 +15,10 @@ template<typename A, typename B>
 struct TryPair;
 struct InternalErrorReporter;
 
+class TypeIds;
 class Normalizer;
 struct NormalizedType;
+struct NormalizedClassType;
 
 struct SubtypingResult
 {
@@ -30,6 +33,8 @@ struct SubtypingResult
     void andAlso(const SubtypingResult& other);
     void orElse(const SubtypingResult& other);
 
+    // Only negates the `isSubtype`.
+    static SubtypingResult negate(const SubtypingResult& result);
     static SubtypingResult all(const std::vector<SubtypingResult>& results);
     static SubtypingResult any(const std::vector<SubtypingResult>& results);
 };
@@ -63,7 +68,7 @@ struct Subtyping
     DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
 
     using SeenSet = std::unordered_set<std::pair<TypeId, TypeId>, TypeIdPairHash>;
-    
+
     SeenSet seenTypes;
 
     // TODO cache
@@ -88,8 +93,19 @@ struct Subtyping
     SubtypingResult isSubtype_(const SingletonType* subSingleton, const PrimitiveType* superPrim);
     SubtypingResult isSubtype_(const SingletonType* subSingleton, const SingletonType* superSingleton);
     SubtypingResult isSubtype_(const TableType* subTable, const TableType* superTable);
+    SubtypingResult isSubtype_(const MetatableType* subMt, const MetatableType* superMt);
+    SubtypingResult isSubtype_(const MetatableType* subMt, const TableType* superTable);
+    SubtypingResult isSubtype_(const ClassType* subClass, const ClassType* superClass);
+    SubtypingResult isSubtype_(const ClassType* subClass, const TableType* superTable); // Actually a class <: shape.
     SubtypingResult isSubtype_(const FunctionType* subFunction, const FunctionType* superFunction);
+    SubtypingResult isSubtype_(const PrimitiveType* subPrim, const TableType* superTable);
+    SubtypingResult isSubtype_(const SingletonType* subSingleton, const TableType* superTable);
+
     SubtypingResult isSubtype_(const NormalizedType* subNorm, const NormalizedType* superNorm);
+    SubtypingResult isSubtype_(const NormalizedClassType& subClass, const NormalizedClassType& superClass, const TypeIds& superTables);
+    SubtypingResult isSubtype_(const TypeIds& subTypes, const TypeIds& superTypes);
+
+    SubtypingResult isSubtype_(const VariadicTypePack* subVariadic, const VariadicTypePack* superVariadic);
 
     bool bindGeneric(TypeId subTp, TypeId superTp);
     bool bindGeneric(TypePackId subTp, TypePackId superTp);

diff --git a/Analysis/src/AstJsonEncoder.cpp b/Analysis/src/AstJsonEncoder.cpp
@@ -8,6 +8,8 @@
 
 #include <math.h>
 
+LUAU_FASTFLAG(LuauFloorDivision)
+
 namespace Luau
 {
 
@@ -514,6 +516,9 @@ struct AstJsonEncoder : public AstVisitor
             return writeString("Mul");
         case AstExprBinary::Div:
             return writeString("Div");
+        case AstExprBinary::FloorDiv:
+            LUAU_ASSERT(FFlag::LuauFloorDivision);
+            return writeString("FloorDiv");
         case AstExprBinary::Mod:
             return writeString("Mod");
         case AstExprBinary::Pow:
@@ -536,6 +541,8 @@ struct AstJsonEncoder : public AstVisitor
             return writeString("And");
         case AstExprBinary::Or:
             return writeString("Or");
+        default:
+            LUAU_ASSERT(!"Unknown Op");
         }
     }
 

diff --git a/Analysis/src/Autocomplete.cpp b/Analysis/src/Autocomplete.cpp
@@ -15,6 +15,7 @@
 LUAU_FASTFLAG(DebugLuauReadWriteProperties)
 LUAU_FASTFLAGVARIABLE(LuauAnonymousAutofilled1, false);
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteLastTypecheck, false)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteDoEnd, false)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteStringLiteralBounds, false);
 
 static const std::unordered_set<std::string> kStatementStartingKeywords = {
@@ -1089,14 +1090,19 @@ static AutocompleteEntryMap autocompleteStatement(
     {
         if (AstStatForIn* statForIn = (*it)->as<AstStatForIn>(); statForIn && !statForIn->hasEnd)
             result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
-        if (AstStatFor* statFor = (*it)->as<AstStatFor>(); statFor && !statFor->hasEnd)
+        else if (AstStatFor* statFor = (*it)->as<AstStatFor>(); statFor && !statFor->hasEnd)
             result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
-        if (AstStatIf* statIf = (*it)->as<AstStatIf>(); statIf && !statIf->hasEnd)
+        else if (AstStatIf* statIf = (*it)->as<AstStatIf>(); statIf && !statIf->hasEnd)
             result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
-        if (AstStatWhile* statWhile = (*it)->as<AstStatWhile>(); statWhile && !statWhile->hasEnd)
+        else if (AstStatWhile* statWhile = (*it)->as<AstStatWhile>(); statWhile && !statWhile->hasEnd)
             result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
-        if (AstExprFunction* exprFunction = (*it)->as<AstExprFunction>(); exprFunction && !exprFunction->hasEnd)
+        else if (AstExprFunction* exprFunction = (*it)->as<AstExprFunction>(); exprFunction && !exprFunction->hasEnd)
             result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
+        if (FFlag::LuauAutocompleteDoEnd)
+        {
+            if (AstStatBlock* exprBlock = (*it)->as<AstStatBlock>(); exprBlock && !exprBlock->hasEnd)
+                result.emplace("end", AutocompleteEntry{AutocompleteEntryKind::Keyword});
+        }
     }
 
     if (ancestry.size() >= 2)

diff --git a/Analysis/src/ConstraintGraphBuilder.cpp b/Analysis/src/ConstraintGraphBuilder.cpp
@@ -24,6 +24,7 @@ LUAU_FASTINT(LuauCheckRecursionLimit);
 LUAU_FASTFLAG(DebugLuauLogSolverToJson);
 LUAU_FASTFLAG(DebugLuauMagicTypes);
 LUAU_FASTFLAG(LuauParseDeclareClassIndexer);
+LUAU_FASTFLAG(LuauFloorDivision);
 
 namespace Luau
 {
@@ -1170,7 +1171,8 @@ static bool isMetamethod(const Name& name)
 {
     return name == "__index" || name == "__newindex" || name == "__call" || name == "__concat" || name == "__unm" || name == "__add" ||
            name == "__sub" || name == "__mul" || name == "__div" || name == "__mod" || name == "__pow" || name == "__tostring" ||
-           name == "__metatable" || name == "__eq" || name == "__lt" || name == "__le" || name == "__mode" || name == "__iter" || name == "__len";
+           name == "__metatable" || name == "__eq" || name == "__lt" || name == "__le" || name == "__mode" || name == "__iter" || name == "__len" ||
+           (FFlag::LuauFloorDivision && name == "__idiv");
 }
 
 ControlFlow ConstraintGraphBuilder::visit(const ScopePtr& scope, AstStatDeclareClass* declaredClass)

diff --git a/Analysis/src/ConstraintSolver.cpp b/Analysis/src/ConstraintSolver.cpp
@@ -22,6 +22,7 @@
 #include "Luau/VisitType.h"
 
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolver, false);
+LUAU_FASTFLAG(LuauFloorDivision);
 
 namespace Luau
 {
@@ -719,6 +720,8 @@ bool ConstraintSolver::tryDispatch(const BinaryConstraint& c, NotNull<const Cons
     // Metatables go first, even if there is primitive behavior.
     if (auto it = kBinaryOpMetamethods.find(c.op); it != kBinaryOpMetamethods.end())
     {
+        LUAU_ASSERT(FFlag::LuauFloorDivision || c.op != AstExprBinary::Op::FloorDiv);
+
         // Metatables are not the same. The metamethod will not be invoked.
         if ((c.op == AstExprBinary::Op::CompareEq || c.op == AstExprBinary::Op::CompareNe) &&
             getMetatable(leftType, builtinTypes) != getMetatable(rightType, builtinTypes))
@@ -806,9 +809,12 @@ bool ConstraintSolver::tryDispatch(const BinaryConstraint& c, NotNull<const Cons
     case AstExprBinary::Op::Sub:
     case AstExprBinary::Op::Mul:
     case AstExprBinary::Op::Div:
+    case AstExprBinary::Op::FloorDiv:
     case AstExprBinary::Op::Pow:
     case AstExprBinary::Op::Mod:
     {
+        LUAU_ASSERT(FFlag::LuauFloorDivision || c.op != AstExprBinary::Op::FloorDiv);
+
         const NormalizedType* normLeftTy = normalizer->normalize(leftType);
         if (hasTypeInIntersection<FreeType>(leftType) && force)
             asMutable(leftType)->ty.emplace<BoundType>(anyPresent ? builtinTypes->anyType : builtinTypes->numberType);

diff --git a/Analysis/src/Error.cpp b/Analysis/src/Error.cpp
@@ -12,7 +12,6 @@
 #include <stdexcept>
 #include <type_traits>
 
-LUAU_FASTFLAGVARIABLE(LuauIndentTypeMismatch, false)
 LUAU_FASTINTVARIABLE(LuauIndentTypeMismatchMaxTypeLength, 10)
 
 static std::string wrongNumberOfArgsString(
@@ -94,39 +93,26 @@ struct ErrorConverter
                     {
                         std::string givenModuleName = fileResolver->getHumanReadableModuleName(*givenDefinitionModule);
                         std::string wantedModuleName = fileResolver->getHumanReadableModuleName(*wantedDefinitionModule);
-                        if (FFlag::LuauIndentTypeMismatch)
-                            result = constructErrorMessage(givenTypeName, wantedTypeName, givenModuleName, wantedModuleName);
-                        else
-                            result = "Type '" + givenTypeName + "' from '" + givenModuleName + "' could not be converted into '" + wantedTypeName +
-                                     "' from '" + wantedModuleName + "'";
+                        result = constructErrorMessage(givenTypeName, wantedTypeName, givenModuleName, wantedModuleName);
                     }
                     else
                     {
-                        if (FFlag::LuauIndentTypeMismatch)
-                            result = constructErrorMessage(givenTypeName, wantedTypeName, *givenDefinitionModule, *wantedDefinitionModule);
-                        else
-                            result = "Type '" + givenTypeName + "' from '" + *givenDefinitionModule + "' could not be converted into '" +
-                                     wantedTypeName + "' from '" + *wantedDefinitionModule + "'";
+                        result = constructErrorMessage(givenTypeName, wantedTypeName, *givenDefinitionModule, *wantedDefinitionModule);
                     }
                 }
             }
         }
 
         if (result.empty())
-        {
-            if (FFlag::LuauIndentTypeMismatch)
-                result = constructErrorMessage(givenTypeName, wantedTypeName, std::nullopt, std::nullopt);
-            else
-                result = "Type '" + givenTypeName + "' could not be converted into '" + wantedTypeName + "'";
-        }
+            result = constructErrorMessage(givenTypeName, wantedTypeName, std::nullopt, std::nullopt);
 
 
         if (tm.error)
         {
             result += "\ncaused by:\n  ";
 
             if (!tm.reason.empty())
-                result += tm.reason + (FFlag::LuauIndentTypeMismatch ? " \n" : " ");
+                result += tm.reason + " \n";
 
             result += Luau::toString(*tm.error, TypeErrorToStringOptions{fileResolver});
         }