Sync to upstream/release/599 (#1069)

## What's Changed - Improve POSIX compliance in `CLI/FileUtils.cpp` by @SamuraiCrow #1064 - `AstStat*::hasEnd` is deprecated; use `AstStatBlock::hasEnd` instead - Added a lint for common misuses of the `#` operator - Luau now issues deprecated diagnostics for some uses of `getfenv` and `setfenv` - Fixed a case where we included a trailing space in some error stringifications ### Compiler - Do not do further analysis in O2 on self functions - Improve detection of invalid repeat..until expressions vs continue ### New Type Solver - We now cache subtype test results to improve performance - Improved operator inference mechanics (aka type families) - Further work towards type states - Work towards [new non-strict mode](https://github.com/Roblox/luau/blob/master/rfcs/new-nonstrict.md) continues ### Native Codegen - Instruction last use locations should follow the order in which blocks are lowered - Add a bonus assertion to IrLoweringA64::tempAddr --- Co-authored-by: Arseny Kapoulkine <[email protected]> Co-authored-by: Vyacheslav Egorov <[email protected]> Co-authored-by: Andy Friesen <[email protected]> Co-authored-by: Aaron Weiss <[email protected]> Co-authored-by: Alexander McCord <[email protected]> Co-authored-by: Vighnesh Vijay <[email protected]>
luau-lang · Oct 13, 2023 · 24fdac4 · 24fdac4
1 parent 5c94984
commit 24fdac4
Show file tree

Hide file tree

Showing 59 changed files with 2,437 additions and 950 deletions.
diff --git a/Analysis/include/Luau/ConstraintGraphBuilder.h b/Analysis/include/Luau/ConstraintGraphBuilder.h
@@ -69,6 +69,12 @@ struct ConstraintGraphBuilder
     // This is null when the CGB is initially constructed.
     Scope* rootScope;
 
+    // During constraint generation, we only populate the Scope::bindings
+    // property for annotated symbols.  Unannotated symbols must be handled in a
+    // postprocessing step because we do not yet have the full breadcrumb graph.
+    // We queue them up here.
+    std::vector<std::tuple<Scope*, Symbol, BreadcrumbId>> inferredBindings;
+
     // Constraints that go straight to the solver.
     std::vector<ConstraintPtr> constraints;
 
@@ -205,8 +211,6 @@ struct ConstraintGraphBuilder
     Inference check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
     std::tuple<TypeId, TypeId, RefinementId> checkBinary(const ScopePtr& scope, AstExprBinary* binary, std::optional<TypeId> expectedType);
 
-    std::vector<TypeId> checkLValues(const ScopePtr& scope, AstArray<AstExpr*> exprs);
-
     TypeId checkLValue(const ScopePtr& scope, AstExpr* expr);
     TypeId checkLValue(const ScopePtr& scope, AstExprLocal* local);
     TypeId checkLValue(const ScopePtr& scope, AstExprGlobal* global);
@@ -303,6 +307,8 @@ struct ConstraintGraphBuilder
      */
     void prepopulateGlobalScope(const ScopePtr& globalScope, AstStatBlock* program);
 
+    void fillInInferredBindings(const ScopePtr& globalScope, AstStatBlock* block);
+
     /** 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]

diff --git a/Analysis/include/Luau/DataFlowGraph.h b/Analysis/include/Luau/DataFlowGraph.h
@@ -120,12 +120,12 @@ struct DataFlowGraphBuilder
     BreadcrumbId visitExpr(DfgScope* scope, AstExprInterpString* i);
     BreadcrumbId visitExpr(DfgScope* scope, AstExprError* error);
 
-    void visitLValue(DfgScope* scope, AstExpr* e);
-    void visitLValue(DfgScope* scope, AstExprLocal* l);
-    void visitLValue(DfgScope* scope, AstExprGlobal* g);
-    void visitLValue(DfgScope* scope, AstExprIndexName* i);
-    void visitLValue(DfgScope* scope, AstExprIndexExpr* i);
-    void visitLValue(DfgScope* scope, AstExprError* e);
+    void visitLValue(DfgScope* scope, AstExpr* e, BreadcrumbId bc);
+    void visitLValue(DfgScope* scope, AstExprLocal* l, BreadcrumbId bc);
+    void visitLValue(DfgScope* scope, AstExprGlobal* g, BreadcrumbId bc);
+    void visitLValue(DfgScope* scope, AstExprIndexName* i, BreadcrumbId bc);
+    void visitLValue(DfgScope* scope, AstExprIndexExpr* i, BreadcrumbId bc);
+    void visitLValue(DfgScope* scope, AstExprError* e, BreadcrumbId bc);
 
     void visitType(DfgScope* scope, AstType* t);
     void visitType(DfgScope* scope, AstTypeReference* r);

diff --git a/Analysis/include/Luau/Error.h b/Analysis/include/Luau/Error.h
@@ -358,13 +358,23 @@ struct PackWhereClauseNeeded
     bool operator==(const PackWhereClauseNeeded& rhs) const;
 };
 
+struct CheckedFunctionCallError
+{
+    TypeId expected;
+    TypeId passed;
+    std::string checkedFunctionName;
+    // TODO: make this a vector<argumentIndices>
+    size_t argumentIndex;
+    bool operator==(const CheckedFunctionCallError& rhs) const;
+};
+
 using TypeErrorData = Variant<TypeMismatch, UnknownSymbol, UnknownProperty, NotATable, CannotExtendTable, OnlyTablesCanHaveMethods,
     DuplicateTypeDefinition, CountMismatch, FunctionDoesNotTakeSelf, FunctionRequiresSelf, OccursCheckFailed, UnknownRequire,
     IncorrectGenericParameterCount, SyntaxError, CodeTooComplex, UnificationTooComplex, UnknownPropButFoundLikeProp, GenericError, InternalError,
     CannotCallNonFunction, ExtraInformation, DeprecatedApiUsed, ModuleHasCyclicDependency, IllegalRequire, FunctionExitsWithoutReturning,
     DuplicateGenericParameter, CannotInferBinaryOperation, MissingProperties, SwappedGenericTypeParameter, OptionalValueAccess, MissingUnionProperty,
     TypesAreUnrelated, NormalizationTooComplex, TypePackMismatch, DynamicPropertyLookupOnClassesUnsafe, UninhabitedTypeFamily,
-    UninhabitedTypePackFamily, WhereClauseNeeded, PackWhereClauseNeeded>;
+    UninhabitedTypePackFamily, WhereClauseNeeded, PackWhereClauseNeeded, CheckedFunctionCallError>;
 
 struct TypeErrorSummary
 {

diff --git a/Analysis/include/Luau/Frontend.h b/Analysis/include/Luau/Frontend.h
@@ -245,12 +245,12 @@ struct Frontend
     std::vector<ModuleName> moduleQueue;
 };
 
-ModulePtr check(const SourceModule& sourceModule, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
+ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
     NotNull<InternalErrorReporter> iceHandler, NotNull<ModuleResolver> moduleResolver, NotNull<FileResolver> fileResolver,
     const ScopePtr& globalScope, std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope, FrontendOptions options,
     TypeCheckLimits limits);
 
-ModulePtr check(const SourceModule& sourceModule, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
+ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
     NotNull<InternalErrorReporter> iceHandler, NotNull<ModuleResolver> moduleResolver, NotNull<FileResolver> fileResolver,
     const ScopePtr& globalScope, std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope, FrontendOptions options,
     TypeCheckLimits limits, bool recordJsonLog);

diff --git a/Analysis/include/Luau/NonStrictTypeChecker.h b/Analysis/include/Luau/NonStrictTypeChecker.h
@@ -3,13 +3,17 @@
 
 #include "Luau/Module.h"
 #include "Luau/NotNull.h"
+#include "Luau/DataFlowGraph.h"
 
 namespace Luau
 {
 
 struct BuiltinTypes;
+struct UnifierSharedState;
+struct TypeCheckLimits;
 
+void checkNonStrict(NotNull<BuiltinTypes> builtinTypes, NotNull<InternalErrorReporter> ice, NotNull<UnifierSharedState> unifierState,
+    NotNull<const DataFlowGraph> dfg, NotNull<TypeCheckLimits> limits, const SourceModule& sourceModule, Module* module);
 
-void checkNonStrict(NotNull<BuiltinTypes> builtinTypes, Module* module);
 
 } // namespace Luau
diff --git a/Analysis/include/Luau/Subtyping.h b/Analysis/include/Luau/Subtyping.h
@@ -3,6 +3,7 @@
 
 #include "Luau/Type.h"
 #include "Luau/TypePack.h"
+#include "Luau/TypePairHash.h"
 #include "Luau/UnifierSharedState.h"
 
 #include <vector>
@@ -28,6 +29,7 @@ struct SubtypingResult
     bool isSubtype = false;
     bool isErrorSuppressing = false;
     bool normalizationTooComplex = false;
+    bool isCacheable = true;
 
     SubtypingResult& andAlso(const SubtypingResult& other);
     SubtypingResult& orElse(const SubtypingResult& other);
@@ -38,6 +40,24 @@ struct SubtypingResult
     static SubtypingResult any(const std::vector<SubtypingResult>& results);
 };
 
+struct SubtypingEnvironment
+{
+    struct GenericBounds
+    {
+        DenseHashSet<TypeId> lowerBound{nullptr};
+        DenseHashSet<TypeId> upperBound{nullptr};
+    };
+
+    /*
+     * When we encounter a generic over the course of a subtyping test, we need
+     * to tentatively map that generic onto a type on the other side.
+     */
+    DenseHashMap<TypeId, GenericBounds> mappedGenerics{nullptr};
+    DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
+
+    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> ephemeralCache{{}};
+};
+
 struct Subtyping
 {
     NotNull<BuiltinTypes> builtinTypes;
@@ -55,29 +75,25 @@ struct Subtyping
 
     Variance variance = Variance::Covariant;
 
-    struct GenericBounds
-    {
-        DenseHashSet<TypeId> lowerBound{nullptr};
-        DenseHashSet<TypeId> upperBound{nullptr};
-    };
-
-    /*
-     * When we encounter a generic over the course of a subtyping test, we need
-     * to tentatively map that generic onto a type on the other side.
-     */
-    DenseHashMap<TypeId, GenericBounds> mappedGenerics{nullptr};
-    DenseHashMap<TypePackId, TypePackId> mappedGenericPacks{nullptr};
-
     using SeenSet = std::unordered_set<std::pair<TypeId, TypeId>, TypeIdPairHash>;
 
     SeenSet seenTypes;
 
+    Subtyping(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> typeArena, NotNull<Normalizer> normalizer,
+        NotNull<InternalErrorReporter> iceReporter, NotNull<Scope> scope);
+
     Subtyping(const Subtyping&) = delete;
     Subtyping& operator=(const Subtyping&) = delete;
 
     Subtyping(Subtyping&&) = default;
     Subtyping& operator=(Subtyping&&) = default;
 
+    // Only used by unit tests to test that the cache works.
+    const DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash>& peekCache() const
+    {
+        return resultCache;
+    }
+
     // TODO cache
     // TODO cyclic types
     // TODO recursion limits
@@ -86,58 +102,63 @@ struct Subtyping
     SubtypingResult isSubtype(TypePackId subTy, TypePackId superTy);
 
 private:
-    SubtypingResult isCovariantWith(TypeId subTy, TypeId superTy);
-    SubtypingResult isCovariantWith(TypePackId subTy, TypePackId superTy);
+    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> resultCache{{}};
+
+    SubtypingResult cache(SubtypingEnvironment& env, SubtypingResult res, TypeId subTy, TypeId superTy);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, TypeId superTy);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypePackId subTy, TypePackId superTy);
 
     template<typename SubTy, typename SuperTy>
-    SubtypingResult isContravariantWith(SubTy&& subTy, SuperTy&& superTy);
+    SubtypingResult isContravariantWith(SubtypingEnvironment& env, SubTy&& subTy, SuperTy&& superTy);
 
     template<typename SubTy, typename SuperTy>
-    SubtypingResult isInvariantWith(SubTy&& subTy, SuperTy&& superTy);
+    SubtypingResult isInvariantWith(SubtypingEnvironment& env, SubTy&& subTy, SuperTy&& superTy);
 
     template<typename SubTy, typename SuperTy>
-    SubtypingResult isCovariantWith(const TryPair<const SubTy*, const SuperTy*>& pair);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair);
 
     template<typename SubTy, typename SuperTy>
-    SubtypingResult isContravariantWith(const TryPair<const SubTy*, const SuperTy*>& pair);
+    SubtypingResult isContravariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair);
 
     template<typename SubTy, typename SuperTy>
-    SubtypingResult isInvariantWith(const TryPair<const SubTy*, const SuperTy*>& pair);
-
-    SubtypingResult isCovariantWith(TypeId subTy, const UnionType* superUnion);
-    SubtypingResult isCovariantWith(const UnionType* subUnion, TypeId superTy);
-    SubtypingResult isCovariantWith(TypeId subTy, const IntersectionType* superIntersection);
-    SubtypingResult isCovariantWith(const IntersectionType* subIntersection, TypeId superTy);
-
-    SubtypingResult isCovariantWith(const NegationType* subNegation, TypeId superTy);
-    SubtypingResult isCovariantWith(const TypeId subTy, const NegationType* superNegation);
-
-    SubtypingResult isCovariantWith(const PrimitiveType* subPrim, const PrimitiveType* superPrim);
-    SubtypingResult isCovariantWith(const SingletonType* subSingleton, const PrimitiveType* superPrim);
-    SubtypingResult isCovariantWith(const SingletonType* subSingleton, const SingletonType* superSingleton);
-    SubtypingResult isCovariantWith(const TableType* subTable, const TableType* superTable);
-    SubtypingResult isCovariantWith(const MetatableType* subMt, const MetatableType* superMt);
-    SubtypingResult isCovariantWith(const MetatableType* subMt, const TableType* superTable);
-    SubtypingResult isCovariantWith(const ClassType* subClass, const ClassType* superClass);
-    SubtypingResult isCovariantWith(const ClassType* subClass, const TableType* superTable);
-    SubtypingResult isCovariantWith(const FunctionType* subFunction, const FunctionType* superFunction);
-    SubtypingResult isCovariantWith(const PrimitiveType* subPrim, const TableType* superTable);
-    SubtypingResult isCovariantWith(const SingletonType* subSingleton, const TableType* superTable);
-
-    SubtypingResult isCovariantWith(const TableIndexer& subIndexer, const TableIndexer& superIndexer);
-
-    SubtypingResult isCovariantWith(const NormalizedType* subNorm, const NormalizedType* superNorm);
-    SubtypingResult isCovariantWith(const NormalizedClassType& subClass, const NormalizedClassType& superClass);
-    SubtypingResult isCovariantWith(const NormalizedClassType& subClass, const TypeIds& superTables);
-    SubtypingResult isCovariantWith(const NormalizedStringType& subString, const NormalizedStringType& superString);
-    SubtypingResult isCovariantWith(const NormalizedStringType& subString, const TypeIds& superTables);
-    SubtypingResult isCovariantWith(const NormalizedFunctionType& subFunction, const NormalizedFunctionType& superFunction);
-    SubtypingResult isCovariantWith(const TypeIds& subTypes, const TypeIds& superTypes);
-
-    SubtypingResult isCovariantWith(const VariadicTypePack* subVariadic, const VariadicTypePack* superVariadic);
-
-    bool bindGeneric(TypeId subTp, TypeId superTp);
-    bool bindGeneric(TypePackId subTp, TypePackId superTp);
+    SubtypingResult isInvariantWith(SubtypingEnvironment& env, const TryPair<const SubTy*, const SuperTy*>& pair);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const UnionType* superUnion);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const UnionType* subUnion, TypeId superTy);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, TypeId subTy, const IntersectionType* superIntersection);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const IntersectionType* subIntersection, TypeId superTy);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NegationType* subNegation, TypeId superTy);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TypeId subTy, const NegationType* superNegation);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const PrimitiveType* subPrim, const PrimitiveType* superPrim);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const SingletonType* subSingleton, const PrimitiveType* superPrim);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const SingletonType* subSingleton, const SingletonType* superSingleton);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const MetatableType* superMt);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const MetatableType* subMt, const TableType* superTable);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const ClassType* subClass, const ClassType* superClass);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const ClassType* subClass, const TableType* superTable);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const FunctionType* subFunction, const FunctionType* superFunction);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const PrimitiveType* subPrim, const TableType* superTable);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const SingletonType* subSingleton, const TableType* superTable);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableIndexer& subIndexer, const TableIndexer& superIndexer);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedType* subNorm, const NormalizedType* superNorm);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedClassType& subClass, const NormalizedClassType& superClass);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedClassType& subClass, const TypeIds& superTables);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedStringType& subString, const NormalizedStringType& superString);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const NormalizedStringType& subString, const TypeIds& superTables);
+    SubtypingResult isCovariantWith(
+        SubtypingEnvironment& env, const NormalizedFunctionType& subFunction, const NormalizedFunctionType& superFunction);
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TypeIds& subTypes, const TypeIds& superTypes);
+
+    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const VariadicTypePack* subVariadic, const VariadicTypePack* superVariadic);
+
+    bool bindGeneric(SubtypingEnvironment& env, TypeId subTp, TypeId superTp);
+    bool bindGeneric(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp);
 
     template<typename T, typename Container>
     TypeId makeAggregateType(const Container& container, TypeId orElse);

diff --git a/Analysis/include/Luau/TypeFamily.h b/Analysis/include/Luau/TypeFamily.h
@@ -93,7 +93,7 @@ struct TypeFamily
     std::string name;
 
     /// The reducer function for the type family.
-    std::function<TypeFamilyReductionResult<TypeId>(std::vector<TypeId>, std::vector<TypePackId>, NotNull<TypeFamilyContext>)> reducer;
+    std::function<TypeFamilyReductionResult<TypeId>(const std::vector<TypeId>&, const std::vector<TypePackId>&, NotNull<TypeFamilyContext>)> reducer;
 };
 
 /// Represents a type function that may be applied to map a series of types and
@@ -105,7 +105,7 @@ struct TypePackFamily
     std::string name;
 
     /// The reducer function for the type pack family.
-    std::function<TypeFamilyReductionResult<TypePackId>(std::vector<TypeId>, std::vector<TypePackId>, NotNull<TypeFamilyContext>)> reducer;
+    std::function<TypeFamilyReductionResult<TypePackId>(const std::vector<TypeId>&, const std::vector<TypePackId>&, NotNull<TypeFamilyContext>)> reducer;
 };
 
 struct FamilyGraphReductionResult
@@ -149,6 +149,8 @@ struct BuiltinTypeFamilies
 {
     BuiltinTypeFamilies();
 
+    TypeFamily notFamily;
+
     TypeFamily addFamily;
     TypeFamily subFamily;
     TypeFamily mulFamily;
@@ -157,9 +159,15 @@ struct BuiltinTypeFamilies
     TypeFamily powFamily;
     TypeFamily modFamily;
 
+    TypeFamily concatFamily;
+
     TypeFamily andFamily;
     TypeFamily orFamily;
 
+    TypeFamily ltFamily;
+    TypeFamily leFamily;
+    TypeFamily eqFamily;
+
     void addToScope(NotNull<TypeArena> arena, NotNull<Scope> scope) const;
 };
 

diff --git a/Analysis/include/Luau/TypePairHash.h b/Analysis/include/Luau/TypePairHash.h
@@ -0,0 +1,34 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Type.h"
+
+#include <utility>
+
+namespace Luau
+{
+
+struct TypePairHash
+{
+    size_t hashOne(TypeId key) const
+    {
+        return (uintptr_t(key) >> 4) ^ (uintptr_t(key) >> 9);
+    }
+
+    size_t hashOne(TypePackId key) const
+    {
+        return (uintptr_t(key) >> 4) ^ (uintptr_t(key) >> 9);
+    }
+
+    size_t operator()(const std::pair<TypeId, TypeId>& x) const
+    {
+        return hashOne(x.first) ^ (hashOne(x.second) << 1);
+    }
+
+    size_t operator()(const std::pair<TypePackId, TypePackId>& x) const
+    {
+        return hashOne(x.first) ^ (hashOne(x.second) << 1);
+    }
+};
+
+} // namespace Luau