Sync to upstream/release/527 (#491)

luau-lang · May 20, 2022 · f5923ae · f5923ae
1 parent 8b4c6aa
commit f5923ae
Show file tree

Hide file tree

Showing 52 changed files with 1,095 additions and 1,367 deletions.
diff --git a/Analysis/include/Luau/Clone.h b/Analysis/include/Luau/Clone.h
@@ -1,6 +1,7 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/TypeArena.h"
 #include "Luau/TypeVar.h"
 
 #include <unordered_map>
@@ -18,7 +19,6 @@ struct CloneState
     SeenTypePacks seenTypePacks;
 
     int recursionCount = 0;
-    bool encounteredFreeType = false; // TODO: Remove with LuauLosslessClone.
 };
 
 TypePackId clone(TypePackId tp, TypeArena& dest, CloneState& cloneState);

diff --git a/Analysis/include/Luau/Error.h b/Analysis/include/Luau/Error.h
@@ -5,6 +5,7 @@
 #include "Luau/Location.h"
 #include "Luau/TypeVar.h"
 #include "Luau/Variant.h"
+#include "Luau/TypeArena.h"
 
 namespace Luau
 {
@@ -108,9 +109,6 @@ struct FunctionDoesNotTakeSelf
 
 struct FunctionRequiresSelf
 {
-    // TODO: Delete with LuauAnyInIsOptionalIsOptional
-    int requiredExtraNils = 0;
-
     bool operator==(const FunctionRequiresSelf& rhs) const;
 };
 

diff --git a/Analysis/include/Luau/LValue.h b/Analysis/include/Luau/LValue.h
@@ -34,10 +34,6 @@ const LValue* baseof(const LValue& lvalue);
 
 std::optional<LValue> tryGetLValue(const class AstExpr& expr);
 
-// Utility function: breaks down an LValue to get at the Symbol, and reverses the vector of keys.
-// TODO: remove with FFlagLuauTypecheckOptPass
-std::pair<Symbol, std::vector<std::string>> getFullName(const LValue& lvalue);
-
 // Utility function: breaks down an LValue to get at the Symbol
 Symbol getBaseSymbol(const LValue& lvalue);
 

diff --git a/Analysis/include/Luau/Module.h b/Analysis/include/Luau/Module.h
@@ -2,11 +2,10 @@
 #pragma once
 
 #include "Luau/FileResolver.h"
-#include "Luau/TypePack.h"
-#include "Luau/TypedAllocator.h"
 #include "Luau/ParseOptions.h"
 #include "Luau/Error.h"
 #include "Luau/ParseResult.h"
+#include "Luau/TypeArena.h"
 
 #include <memory>
 #include <vector>
@@ -54,35 +53,6 @@ struct RequireCycle
     std::vector<ModuleName> path; // one of the paths for a require() to go all the way back to the originating module
 };
 
-struct TypeArena
-{
-    TypedAllocator<TypeVar> typeVars;
-    TypedAllocator<TypePackVar> typePacks;
-
-    void clear();
-
-    template<typename T>
-    TypeId addType(T tv)
-    {
-        if constexpr (std::is_same_v<T, UnionTypeVar>)
-            LUAU_ASSERT(tv.options.size() >= 2);
-
-        return addTV(TypeVar(std::move(tv)));
-    }
-
-    TypeId addTV(TypeVar&& tv);
-
-    TypeId freshType(TypeLevel level);
-
-    TypePackId addTypePack(std::initializer_list<TypeId> types);
-    TypePackId addTypePack(std::vector<TypeId> types);
-    TypePackId addTypePack(TypePack pack);
-    TypePackId addTypePack(TypePackVar pack);
-};
-
-void freeze(TypeArena& arena);
-void unfreeze(TypeArena& arena);
-
 struct Module
 {
     ~Module();
@@ -111,9 +81,7 @@ struct Module
 
     // Once a module has been typechecked, we clone its public interface into a separate arena.
     // This helps us to force TypeVar ownership into a DAG rather than a DCG.
-    // Returns true if there were any free types encountered in the public interface. This
-    // indicates a bug in the type checker that we want to surface.
-    bool clonePublicInterface(InternalErrorReporter& ice);
+    void clonePublicInterface(InternalErrorReporter& ice);
 };
 
 } // namespace Luau
diff --git a/Analysis/include/Luau/Substitution.h b/Analysis/include/Luau/Substitution.h
@@ -1,8 +1,7 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
-#include "Luau/Module.h"
-#include "Luau/ModuleResolver.h"
+#include "Luau/TypeArena.h"
 #include "Luau/TypePack.h"
 #include "Luau/TypeVar.h"
 #include "Luau/DenseHash.h"

diff --git a/Analysis/include/Luau/TxnLog.h b/Analysis/include/Luau/TxnLog.h
@@ -7,8 +7,6 @@
 #include "Luau/TypeVar.h"
 #include "Luau/TypePack.h"
 
-LUAU_FASTFLAG(LuauTypecheckOptPass)
-
 namespace Luau
 {
 
@@ -93,15 +91,6 @@ struct TxnLog
     {
     }
 
-    TxnLog(TxnLog* parent, std::vector<std::pair<TypeOrPackId, TypeOrPackId>>* sharedSeen)
-        : typeVarChanges(nullptr)
-        , typePackChanges(nullptr)
-        , parent(parent)
-        , sharedSeen(sharedSeen)
-    {
-        LUAU_ASSERT(!FFlag::LuauTypecheckOptPass);
-    }
-
     TxnLog(const TxnLog&) = delete;
     TxnLog& operator=(const TxnLog&) = delete;
 

diff --git a/Analysis/include/Luau/TypeArena.h b/Analysis/include/Luau/TypeArena.h
@@ -0,0 +1,42 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/TypedAllocator.h"
+#include "Luau/TypeVar.h"
+#include "Luau/TypePack.h"
+
+#include <vector>
+
+namespace Luau
+{
+
+struct TypeArena
+{
+    TypedAllocator<TypeVar> typeVars;
+    TypedAllocator<TypePackVar> typePacks;
+
+    void clear();
+
+    template<typename T>
+    TypeId addType(T tv)
+    {
+        if constexpr (std::is_same_v<T, UnionTypeVar>)
+            LUAU_ASSERT(tv.options.size() >= 2);
+
+        return addTV(TypeVar(std::move(tv)));
+    }
+
+    TypeId addTV(TypeVar&& tv);
+
+    TypeId freshType(TypeLevel level);
+
+    TypePackId addTypePack(std::initializer_list<TypeId> types);
+    TypePackId addTypePack(std::vector<TypeId> types);
+    TypePackId addTypePack(TypePack pack);
+    TypePackId addTypePack(TypePackVar pack);
+};
+
+void freeze(TypeArena& arena);
+void unfreeze(TypeArena& arena);
+
+}
diff --git a/Analysis/include/Luau/TypeInfer.h b/Analysis/include/Luau/TypeInfer.h
@@ -187,7 +187,6 @@ struct TypeChecker
     ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprIndexExpr& expr);
     ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprFunction& expr, std::optional<TypeId> expectedType = std::nullopt);
     ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprTable& expr, std::optional<TypeId> expectedType = std::nullopt);
-    ExprResult<TypeId> checkExpr_(const ScopePtr& scope, const AstExprTable& expr, std::optional<TypeId> expectedType = std::nullopt);
     ExprResult<TypeId> checkExpr(const ScopePtr& scope, const AstExprUnary& expr);
     TypeId checkRelationalOperation(
         const ScopePtr& scope, const AstExprBinary& expr, TypeId lhsType, TypeId rhsType, const PredicateVec& predicates = {});
@@ -395,22 +394,22 @@ struct TypeChecker
         const AstArray<AstGenericType>& genericNames, const AstArray<AstGenericTypePack>& genericPackNames, bool useCache = false);
 
 public:
-    ErrorVec resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
+    void resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
 
 private:
     void refineLValue(const LValue& lvalue, RefinementMap& refis, const ScopePtr& scope, TypeIdPredicate predicate);
 
     std::optional<TypeId> resolveLValue(const ScopePtr& scope, const LValue& lvalue);
     std::optional<TypeId> resolveLValue(const RefinementMap& refis, const ScopePtr& scope, const LValue& lvalue);
 
-    void resolve(const PredicateVec& predicates, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr = false);
-    void resolve(const Predicate& predicate, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
-    void resolve(const TruthyPredicate& truthyP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
-    void resolve(const AndPredicate& andP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const OrPredicate& orP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const IsAPredicate& isaP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const TypeGuardPredicate& typeguardP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
-    void resolve(const EqPredicate& eqP, ErrorVec& errVec, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const PredicateVec& predicates, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr = false);
+    void resolve(const Predicate& predicate, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
+    void resolve(const TruthyPredicate& truthyP, RefinementMap& refis, const ScopePtr& scope, bool sense, bool fromOr);
+    void resolve(const AndPredicate& andP, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const OrPredicate& orP, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const IsAPredicate& isaP, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const TypeGuardPredicate& typeguardP, RefinementMap& refis, const ScopePtr& scope, bool sense);
+    void resolve(const EqPredicate& eqP, RefinementMap& refis, const ScopePtr& scope, bool sense);
 
     bool isNonstrictMode() const;
     bool useConstrainedIntersections() const;

diff --git a/Analysis/include/Luau/Unifier.h b/Analysis/include/Luau/Unifier.h
@@ -5,7 +5,7 @@
 #include "Luau/Location.h"
 #include "Luau/TxnLog.h"
 #include "Luau/TypeInfer.h"
-#include "Luau/Module.h" // FIXME: For TypeArena.  It merits breaking out into its own header.
+#include "Luau/TypeArena.h"
 #include "Luau/UnifierSharedState.h"
 
 #include <unordered_set>
@@ -55,8 +55,6 @@ struct Unifier
     UnifierSharedState& sharedState;
 
     Unifier(TypeArena* types, Mode mode, const Location& location, Variance variance, UnifierSharedState& sharedState, TxnLog* parentLog = nullptr);
-    Unifier(TypeArena* types, Mode mode, std::vector<std::pair<TypeOrPackId, TypeOrPackId>>* sharedSeen, const Location& location, Variance variance,
-        UnifierSharedState& sharedState, TxnLog* parentLog = nullptr);
 
     // Test whether the two type vars unify.  Never commits the result.
     ErrorVec canUnify(TypeId subTy, TypeId superTy);

diff --git a/Analysis/include/Luau/VisitTypeVar.h b/Analysis/include/Luau/VisitTypeVar.h
@@ -10,6 +10,7 @@
 
 LUAU_FASTFLAG(LuauUseVisitRecursionLimit)
 LUAU_FASTINT(LuauVisitRecursionLimit)
+LUAU_FASTFLAG(LuauNormalizeFlagIsConservative)
 
 namespace Luau
 {
@@ -471,18 +472,21 @@ struct GenericTypeVarVisitor
 
         else if (auto pack = get<TypePack>(tp))
         {
-            visit(tp, *pack);
-
-            for (TypeId ty : pack->head)
-                traverse(ty);
+            bool res = visit(tp, *pack);
+            if (!FFlag::LuauNormalizeFlagIsConservative || res)
+            {
+                for (TypeId ty : pack->head)
+                    traverse(ty);
 
-            if (pack->tail)
-                traverse(*pack->tail);
+                if (pack->tail)
+                    traverse(*pack->tail);
+            }
         }
         else if (auto pack = get<VariadicTypePack>(tp))
         {
-            visit(tp, *pack);
-            traverse(pack->ty);
+            bool res = visit(tp, *pack);
+            if (!FFlag::LuauNormalizeFlagIsConservative || res)
+                traverse(pack->ty);
         }
         else
             LUAU_ASSERT(!"GenericTypeVarVisitor::traverse(TypePackId) is not exhaustive!");

diff --git a/Analysis/src/BuiltinDefinitions.cpp b/Analysis/src/BuiltinDefinitions.cpp
@@ -8,7 +8,6 @@
 
 #include <algorithm>
 
-LUAU_FASTFLAG(LuauAssertStripsFalsyTypes)
 LUAU_FASTFLAGVARIABLE(LuauSetMetaTableArgsCheck, false)
 
 /** FIXME: Many of these type definitions are not quite completely accurate.
@@ -408,41 +407,29 @@ static std::optional<ExprResult<TypePackId>> magicFunctionAssert(
 {
     auto [paramPack, predicates] = exprResult;
 
-    if (FFlag::LuauAssertStripsFalsyTypes)
-    {
-        TypeArena& arena = typechecker.currentModule->internalTypes;
-
-        auto [head, tail] = flatten(paramPack);
-        if (head.empty() && tail)
-        {
-            std::optional<TypeId> fst = first(*tail);
-            if (!fst)
-                return ExprResult<TypePackId>{paramPack};
-            head.push_back(*fst);
-        }
-
-        typechecker.reportErrors(typechecker.resolve(predicates, scope, true));
-
-        if (head.size() > 0)
-        {
-            std::optional<TypeId> newhead = typechecker.pickTypesFromSense(head[0], true);
-            if (!newhead)
-                head = {typechecker.nilType};
-            else
-                head[0] = *newhead;
-        }
+    TypeArena& arena = typechecker.currentModule->internalTypes;
 
-        return ExprResult<TypePackId>{arena.addTypePack(TypePack{std::move(head), tail})};
-    }
-    else
+    auto [head, tail] = flatten(paramPack);
+    if (head.empty() && tail)
     {
-        if (expr.args.size < 1)
+        std::optional<TypeId> fst = first(*tail);
+        if (!fst)
             return ExprResult<TypePackId>{paramPack};
+        head.push_back(*fst);
+    }
 
-        typechecker.reportErrors(typechecker.resolve(predicates, scope, true));
+    typechecker.resolve(predicates, scope, true);
 
-        return ExprResult<TypePackId>{paramPack};
+    if (head.size() > 0)
+    {
+        std::optional<TypeId> newhead = typechecker.pickTypesFromSense(head[0], true);
+        if (!newhead)
+            head = {typechecker.nilType};
+        else
+            head[0] = *newhead;
     }
+
+    return ExprResult<TypePackId>{arena.addTypePack(TypePack{std::move(head), tail})};
 }
 
 static std::optional<ExprResult<TypePackId>> magicFunctionPack(