@shopify/react-native-skia 0.1.157 → 0.1.159

package/cpp/skia/include/sksl/DSLExpression.h

@@ -16,6 +16,7 @@
 #include <memory>
 #include <string>
 #include <string_view>
+#include <type_traits>
 
 #if defined(__has_cpp_attribute) && __has_cpp_attribute(clang::reinitializes)
 #define SK_CLANG_REINITIALIZES [[clang::reinitializes]]
@@ -30,10 +31,8 @@ class ExpressionArray;
 
 namespace dsl {
 
-class DSLPossibleExpression;
 class DSLType;
 class DSLVarBase;
-template <typename T> class DSLWrapper;
 
 /**
  * Represents an expression such as 'cos(x)' or 'a + b'.
@@ -84,12 +83,8 @@ public:
 
     DSLExpression(DSLVarBase&& var, Position pos = {});
 
-    DSLExpression(DSLPossibleExpression expr, Position pos = {});
-
-    explicit DSLExpression(std::unique_ptr<SkSL::Expression> expression);
-
-    // If expression is null, returns Poison(pos)
-    DSLExpression(std::unique_ptr<SkSL::Expression> expression, Position pos);
+    // If expression is null, returns Poison
+    explicit DSLExpression(std::unique_ptr<SkSL::Expression> expression, Position pos = {});
 
     static DSLExpression Poison(Position pos = {});
 
@@ -104,9 +99,9 @@ public:
     void setPosition(Position pos);
 
     /**
-     * Overloads the '=' operator to create an SkSL assignment statement.
+     * Performs assignment, like the '=' operator.
      */
-    DSLPossibleExpression operator=(DSLExpression other);
+    DSLExpression assign(DSLExpression other);
 
     DSLExpression x(Position pos = {});
 
@@ -132,13 +127,11 @@ public:
     /**
      * Creates an SkSL array index expression.
      */
-    DSLPossibleExpression operator[](DSLExpression index);
+    DSLExpression operator[](DSLExpression index);
 
-    DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
-                                     Position pos = {});
+    DSLExpression operator()(SkTArray<DSLExpression, true> args, Position pos = {});
 
-    DSLPossibleExpression operator()(ExpressionArray args,
-                                     Position pos = {});
+    DSLExpression operator()(ExpressionArray args, Position pos = {});
 
     /**
      * Invokes a prefix operator.
@@ -193,140 +186,56 @@ private:
     friend DSLExpression SampleChild(int index, DSLExpression coords);
 
     friend class DSLCore;
-    friend class DSLFunction;
-    friend class DSLPossibleExpression;
-    friend class DSLType;
     friend class DSLVarBase;
     friend class DSLWriter;
-    template<typename T> friend class DSLWrapper;
 };
 
-DSLPossibleExpression operator+(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator+(DSLExpression expr);
-DSLPossibleExpression operator+=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator-(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator-(DSLExpression expr);
-DSLPossibleExpression operator-=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator*(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator*=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator/(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator/=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator%(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator%=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator<<(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator<<=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator>>(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator>>=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator&&(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator||(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator&(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator&=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator|(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator|=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator^(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator^=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression LogicalXor(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator,(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator,(DSLPossibleExpression left, DSLExpression right);
-DSLPossibleExpression operator,(DSLExpression left, DSLPossibleExpression right);
-DSLPossibleExpression operator,(DSLPossibleExpression left, DSLPossibleExpression right);
-DSLPossibleExpression operator==(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator!=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator>(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator<(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator>=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator<=(DSLExpression left, DSLExpression right);
-DSLPossibleExpression operator!(DSLExpression expr);
-DSLPossibleExpression operator~(DSLExpression expr);
-DSLPossibleExpression operator++(DSLExpression expr);
-DSLPossibleExpression operator++(DSLExpression expr, int);
-DSLPossibleExpression operator--(DSLExpression expr);
-DSLPossibleExpression operator--(DSLExpression expr, int);
-
-/**
- * Represents an Expression which may have failed and/or have pending errors to report. Converting a
- * PossibleExpression into an Expression requires a Position so that any pending errors can be
- * reported at the correct position.
- *
- * PossibleExpression is used instead of Expression in situations where it is not possible to
- * capture the Position at the time of Expression construction (notably in operator overloads, where
- * we cannot add default parameters).
- */
-class DSLPossibleExpression {
-public:
-    DSLPossibleExpression(std::unique_ptr<SkSL::Expression> expression);
-
-    DSLPossibleExpression(DSLPossibleExpression&& other);
-
-    ~DSLPossibleExpression();
-
-    bool valid() const {
-        return fExpression != nullptr;
-    }
-
-    /**
-     * Reports any pending errors at the specified position.
-     */
-    void reportErrors(Position pos);
-
-    DSLType type() const;
-
-    std::string description() const;
-
-    Position position() const;
-
-    DSLExpression x(Position pos = {});
-
-    DSLExpression y(Position pos = {});
-
-    DSLExpression z(Position pos = {});
-
-    DSLExpression w(Position pos = {});
-
-    DSLExpression r(Position pos = {});
-
-    DSLExpression g(Position pos = {});
-
-    DSLExpression b(Position pos = {});
-
-    DSLExpression a(Position pos = {});
-
-    DSLExpression field(std::string_view name, Position pos = {});
-
-    DSLPossibleExpression operator=(DSLExpression expr);
-
-    DSLPossibleExpression operator=(int expr);
-
-    DSLPossibleExpression operator=(float expr);
-
-    DSLPossibleExpression operator=(double expr);
-
-    DSLPossibleExpression operator[](DSLExpression index);
-
-    DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
-                                     Position pos = {});
-
-    DSLPossibleExpression operator()(ExpressionArray args,
-                                     Position pos = {});
-
-    DSLPossibleExpression operator++();
-
-    DSLPossibleExpression operator++(int);
-
-    DSLPossibleExpression operator--();
-
-    DSLPossibleExpression operator--(int);
-
-    std::unique_ptr<SkSL::Expression> release(Position pos = {});
-
-private:
-    std::unique_ptr<SkSL::Expression> fExpression;
-
-    friend class DSLExpression;
-};
+DSLExpression operator+(DSLExpression left, DSLExpression right);
+DSLExpression operator+(DSLExpression expr);
+DSLExpression operator+=(DSLExpression left, DSLExpression right);
+DSLExpression operator-(DSLExpression left, DSLExpression right);
+DSLExpression operator-(DSLExpression expr);
+DSLExpression operator-=(DSLExpression left, DSLExpression right);
+DSLExpression operator*(DSLExpression left, DSLExpression right);
+DSLExpression operator*=(DSLExpression left, DSLExpression right);
+DSLExpression operator/(DSLExpression left, DSLExpression right);
+DSLExpression operator/=(DSLExpression left, DSLExpression right);
+DSLExpression operator%(DSLExpression left, DSLExpression right);
+DSLExpression operator%=(DSLExpression left, DSLExpression right);
+DSLExpression operator<<(DSLExpression left, DSLExpression right);
+DSLExpression operator<<=(DSLExpression left, DSLExpression right);
+DSLExpression operator>>(DSLExpression left, DSLExpression right);
+DSLExpression operator>>=(DSLExpression left, DSLExpression right);
+DSLExpression operator&&(DSLExpression left, DSLExpression right);
+DSLExpression operator||(DSLExpression left, DSLExpression right);
+DSLExpression operator&(DSLExpression left, DSLExpression right);
+DSLExpression operator&=(DSLExpression left, DSLExpression right);
+DSLExpression operator|(DSLExpression left, DSLExpression right);
+DSLExpression operator|=(DSLExpression left, DSLExpression right);
+DSLExpression operator^(DSLExpression left, DSLExpression right);
+DSLExpression operator^=(DSLExpression left, DSLExpression right);
+DSLExpression LogicalXor(DSLExpression left, DSLExpression right);
+DSLExpression operator,(DSLExpression left, DSLExpression right);
+DSLExpression operator==(DSLExpression left, DSLExpression right);
+DSLExpression operator!=(DSLExpression left, DSLExpression right);
+DSLExpression operator>(DSLExpression left, DSLExpression right);
+DSLExpression operator<(DSLExpression left, DSLExpression right);
+DSLExpression operator>=(DSLExpression left, DSLExpression right);
+DSLExpression operator<=(DSLExpression left, DSLExpression right);
+DSLExpression operator!(DSLExpression expr);
+DSLExpression operator~(DSLExpression expr);
+DSLExpression operator++(DSLExpression expr);
+DSLExpression operator++(DSLExpression expr, int);
+DSLExpression operator--(DSLExpression expr);
+DSLExpression operator--(DSLExpression expr, int);
 
 } // namespace dsl
 
 } // namespace SkSL
 
+template <typename T> struct sk_is_trivially_relocatable;
+
+template <>
+struct sk_is_trivially_relocatable<SkSL::dsl::DSLExpression> : std::true_type {};
+
 #endif

package/cpp/skia/include/sksl/DSLFunction.h

@@ -27,7 +27,6 @@ class FunctionDeclaration;
 namespace dsl {
 
 class DSLType;
-template <typename T> class DSLWrapper;
 
 class DSLFunction {
 public:
@@ -40,27 +39,19 @@ public:
                 Parameters&... parameters) {
         SkTArray<DSLParameter*> parameterArray;
         parameterArray.reserve_back(sizeof...(parameters));
+        (parameterArray.push_back(&parameters), ...);
 
-        // in C++17, we could just do:
-        // (parameterArray.push_back(&parameters), ...);
-        int unused[] = {0, (static_cast<void>(parameterArray.push_back(&parameters)), 0)...};
-        static_cast<void>(unused);
         // We can't have a default parameter and a template parameter pack at the same time, so
         // unfortunately we can't capture position from this overload.
         this->init(modifiers, returnType, name, std::move(parameterArray), Position());
     }
 
-    DSLFunction(const DSLType& returnType, std::string_view name,
-                SkTArray<DSLParameter*> parameters, Position pos = {}) {
-        this->init(DSLModifiers(), returnType, name, std::move(parameters), pos);
-    }
-
-    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, std::string_view name,
+    DSLFunction(std::string_view name, const DSLModifiers& modifiers, const DSLType& returnType,
                 SkTArray<DSLParameter*> parameters, Position pos = {}) {
         this->init(modifiers, returnType, name, std::move(parameters), pos);
     }
 
-    DSLFunction(const SkSL::FunctionDeclaration* decl)
+    DSLFunction(SkSL::FunctionDeclaration* decl)
         : fDecl(decl) {}
 
     virtual ~DSLFunction() = default;
@@ -73,6 +64,8 @@ public:
 
     void define(DSLBlock block, Position pos = {});
 
+    void prototype();
+
     /**
      * Invokes the function with the given arguments.
      */
@@ -87,8 +80,7 @@ public:
     /**
      * Invokes the function with the given arguments.
      */
-    DSLExpression call(SkTArray<DSLWrapper<DSLExpression>> args,
-            Position pos = {});
+    DSLExpression call(SkTArray<DSLExpression> args, Position pos = {});
 
     DSLExpression call(ExpressionArray args, Position pos = {});
 
@@ -110,7 +102,7 @@ private:
     void init(DSLModifiers modifiers, const DSLType& returnType, std::string_view name,
               SkTArray<DSLParameter*> params, Position pos);
 
-    const SkSL::FunctionDeclaration* fDecl = nullptr;
+    SkSL::FunctionDeclaration* fDecl = nullptr;
     SkSL::Position fPosition;
 };
 

package/cpp/skia/include/sksl/DSLModifiers.h

@@ -39,7 +39,11 @@ public:
         : fModifiers(layout.fSkSLLayout, flags)
         , fPosition(pos) {}
 
-    int flags() const {
+    int& flags() {
+        return fModifiers.fFlags;
+    }
+
+    const int& flags() const {
         return fModifiers.fFlags;
     }
 
@@ -55,7 +59,6 @@ private:
     friend class DSLCore;
     friend class DSLFunction;
     friend class DSLType;
-    friend class DSLVarBase;
     friend class DSLWriter;
 };
 

package/cpp/skia/include/sksl/DSLStatement.h

@@ -23,8 +23,6 @@ namespace dsl {
 
 class DSLBlock;
 class DSLExpression;
-class DSLPossibleExpression;
-class DSLPossibleStatement;
 
 class DSLStatement {
 public:
@@ -32,18 +30,16 @@ public:
 
     DSLStatement(DSLExpression expr);
 
-    DSLStatement(DSLPossibleExpression expr, Position pos = {});
-
-    DSLStatement(DSLPossibleStatement stmt, Position pos = {});
-
     DSLStatement(DSLBlock block);
 
     DSLStatement(DSLStatement&&) = default;
 
-    DSLStatement(std::unique_ptr<SkSL::Statement> stmt);
-
     DSLStatement(std::unique_ptr<SkSL::Expression> expr);
 
+    DSLStatement(std::unique_ptr<SkSL::Statement> stmt, Position pos);
+
+    DSLStatement(std::unique_ptr<SkSL::Statement> stmt);
+
     ~DSLStatement();
 
     DSLStatement& operator=(DSLStatement&& other) = default;
@@ -72,42 +68,11 @@ private:
 
     std::unique_ptr<SkSL::Statement> fStatement;
 
-    friend class DSLBlock;
     friend class DSLCore;
-    friend class DSLExpression;
-    friend class DSLPossibleStatement;
     friend class DSLWriter;
     friend DSLStatement operator,(DSLStatement left, DSLStatement right);
 };
 
-/**
- * Represents a Statement which may have failed and/or have pending errors to report. Converting a
- * PossibleStatement into a Statement requires a Position so that any pending errors can be
- * reported at the correct position.
- *
- * PossibleStatement is used instead of Statement in situations where it is not possible to capture
- * the Position at the time of Statement construction.
- */
-class DSLPossibleStatement {
-public:
-    DSLPossibleStatement(std::unique_ptr<SkSL::Statement> stmt);
-
-    DSLPossibleStatement(DSLPossibleStatement&& other) = default;
-
-    ~DSLPossibleStatement();
-
-    bool hasValue() { return fStatement != nullptr; }
-
-    std::unique_ptr<SkSL::Statement> release() {
-        return DSLStatement(std::move(*this)).release();
-    }
-
-private:
-    std::unique_ptr<SkSL::Statement> fStatement;
-
-    friend class DSLStatement;
-};
-
 DSLStatement operator,(DSLStatement left, DSLStatement right);
 
 } // namespace dsl

package/cpp/skia/include/sksl/DSLSymbols.h

@@ -24,7 +24,7 @@ class DSLVarBase;
 
 // This header provides methods for manually managing symbol tables in DSL code. They should not be
 // used by normal hand-written DSL code, where we rely on C++ to manage symbols, but are instead
-// needed when DSL objects are being constructed programmatically (as in DSLParser).
+// needed when DSL objects are being constructed programmatically (as in Parser).
 
 /**
  * Pushes a new symbol table onto the symbol table stack.
@@ -49,16 +49,6 @@ std::shared_ptr<SymbolTable> CurrentSymbolTable();
  */
 DSLExpression Symbol(std::string_view name, Position pos = {});
 
-/**
- * Returns true if the name refers to a type (user or built-in) in the current symbol table.
- */
-bool IsType(std::string_view name);
-
-/**
- * Returns true if the name refers to a builtin type.
- */
-bool IsBuiltinType(std::string_view name);
-
 /**
  * Adds a variable to the current symbol table.
  */

package/cpp/skia/include/sksl/DSLType.h

@@ -9,6 +9,7 @@
 #define SKSL_DSL_TYPE
 
 #include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLModifiers.h"
 #include "include/sksl/SkSLPosition.h"
@@ -82,9 +83,7 @@ enum TypeConstant : uint8_t {
 
 class DSLType {
 public:
-    DSLType(TypeConstant tc, Position pos = {})
-        : fTypeConstant(tc)
-        , fPosition(pos) {}
+    DSLType(TypeConstant tc, Position pos = {});
 
     DSLType(const SkSL::Type* type, Position pos = {});
 
@@ -94,6 +93,11 @@ public:
             DSLModifiers* modifiers,
             Position pos = {});
 
+    /**
+     * Returns true if the SkSL type is non-null.
+     */
+    bool hasValue() const { return fSkSLType != nullptr; }
+
     /**
      * Returns true if this type is a bool.
      */
@@ -155,28 +159,30 @@ public:
     bool isEffectChild() const;
 
     template<typename... Args>
-    static DSLPossibleExpression Construct(DSLType type, DSLVarBase& var, Args&&... args) {
+    static DSLExpression Construct(DSLType type, DSLVarBase& var, Args&&... args) {
         DSLExpression argArray[] = {var, args...};
-        return Construct(type, SkMakeSpan(argArray));
+        return Construct(type, SkSpan(argArray));
     }
 
     template<typename... Args>
-    static DSLPossibleExpression Construct(DSLType type, DSLExpression expr, Args&&... args) {
+    static DSLExpression Construct(DSLType type, DSLExpression expr, Args&&... args) {
         DSLExpression argArray[] = {std::move(expr), std::move(args)...};
-        return Construct(type, SkMakeSpan(argArray));
+        return Construct(type, SkSpan(argArray));
     }
 
-    static DSLPossibleExpression Construct(DSLType type, SkSpan<DSLExpression> argArray);
+    static DSLExpression Construct(DSLType type, SkSpan<DSLExpression> argArray);
 
 private:
-    const SkSL::Type& skslType() const;
+    const SkSL::Type& skslType() const {
+        SkASSERT(fSkSLType);
+        return *fSkSLType;
+    }
 
     const SkSL::Type* fSkSLType = nullptr;
-    TypeConstant fTypeConstant = kPoison_Type;
-    Position fPosition;
 
     friend DSLType Array(const DSLType& base, int count, Position pos);
     friend DSLType Struct(std::string_view name, SkSpan<DSLField> fields, Position pos);
+    friend DSLType UnsizedArray(const DSLType& base, Position pos);
     friend class DSLCore;
     friend class DSLFunction;
     friend class DSLVarBase;
@@ -224,6 +230,8 @@ MATRIX_TYPE(Half)
 
 DSLType Array(const DSLType& base, int count, Position pos = {});
 
+DSLType UnsizedArray(const DSLType& base, Position pos = {});
+
 class DSLField {
 public:
     DSLField(const DSLType type, std::string_view name,
@@ -253,7 +261,7 @@ DSLType Struct(std::string_view name, SkSpan<DSLField> fields,
 template<typename... Field>
 DSLType Struct(std::string_view name, Field... fields) {
     DSLField fieldTypes[] = {std::move(fields)...};
-    return Struct(name, SkMakeSpan(fieldTypes), Position());
+    return Struct(name, SkSpan(fieldTypes), Position());
 }
 
 } // namespace dsl