@shopify/react-native-skia 0.1.128 → 0.1.131

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

@@ -8,14 +8,14 @@
 #ifndef SKSL_DSL_EXPRESSION
 #define SKSL_DSL_EXPRESSION
 
-#include "include/core/SkStringView.h"
-#include "include/core/SkTypes.h"
 #include "include/private/SkTArray.h"
-#include "include/sksl/DSLWrapper.h"
-#include "include/sksl/SkSLErrorReporter.h"
+#include "include/sksl/SkSLOperator.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <cstdint>
 #include <memory>
+#include <string>
+#include <string_view>
 
 #if defined(__has_cpp_attribute) && __has_cpp_attribute(clang::reinitializes)
 #define SK_CLANG_REINITIALIZES [[clang::reinitializes]]
@@ -26,14 +26,14 @@
 namespace SkSL {
 
 class Expression;
-class Type;
+class ExpressionArray;
 
 namespace dsl {
 
 class DSLPossibleExpression;
-class DSLStatement;
 class DSLType;
 class DSLVarBase;
+template <typename T> class DSLWrapper;
 
 /**
  * Represents an expression such as 'cos(x)' or 'a + b'.
@@ -49,76 +49,85 @@ public:
     /**
      * Creates an expression representing a literal float.
      */
-    DSLExpression(float value, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(float value, Position pos = {});
 
     /**
      * Creates an expression representing a literal float.
      */
-    DSLExpression(double value, PositionInfo pos = PositionInfo::Capture())
+    DSLExpression(double value, Position pos = {})
         : DSLExpression((float) value) {}
 
     /**
      * Creates an expression representing a literal int.
      */
-    DSLExpression(int value, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(int value, Position pos = {});
 
     /**
      * Creates an expression representing a literal int.
      */
-    DSLExpression(int64_t value, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(int64_t value, Position pos = {});
 
     /**
      * Creates an expression representing a literal uint.
      */
-    DSLExpression(unsigned int value, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(unsigned int value, Position pos = {});
 
     /**
      * Creates an expression representing a literal bool.
      */
-    DSLExpression(bool value, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(bool value, Position pos = {});
 
     /**
      * Creates an expression representing a variable reference.
      */
-    DSLExpression(DSLVarBase& var, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(DSLVarBase& var, Position pos = {});
 
-    DSLExpression(DSLVarBase&& var, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(DSLVarBase&& var, Position pos = {});
 
-    DSLExpression(DSLPossibleExpression expr, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression(DSLPossibleExpression expr, Position pos = {});
 
     explicit DSLExpression(std::unique_ptr<SkSL::Expression> expression);
 
-    static DSLExpression Poison(PositionInfo pos = PositionInfo::Capture());
+    // If expression is null, returns Poison(pos)
+    DSLExpression(std::unique_ptr<SkSL::Expression> expression, Position pos);
+
+    static DSLExpression Poison(Position pos = {});
 
     ~DSLExpression();
 
-    DSLType type();
+    DSLType type() const;
+
+    std::string description() const;
+
+    Position position() const;
+
+    void setPosition(Position pos);
 
     /**
      * Overloads the '=' operator to create an SkSL assignment statement.
      */
     DSLPossibleExpression operator=(DSLExpression other);
 
-    DSLExpression x(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression x(Position pos = {});
 
-    DSLExpression y(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression y(Position pos = {});
 
-    DSLExpression z(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression z(Position pos = {});
 
-    DSLExpression w(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression w(Position pos = {});
 
-    DSLExpression r(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression r(Position pos = {});
 
-    DSLExpression g(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression g(Position pos = {});
 
-    DSLExpression b(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression b(Position pos = {});
 
-    DSLExpression a(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression a(Position pos = {});
 
     /**
      * Creates an SkSL struct field access expression.
      */
-    DSLExpression field(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression field(std::string_view name, Position pos = {});
 
     /**
      * Creates an SkSL array index expression.
@@ -126,10 +135,30 @@ public:
     DSLPossibleExpression operator[](DSLExpression index);
 
     DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
-                                     PositionInfo pos = PositionInfo::Capture());
+                                     Position pos = {});
 
     DSLPossibleExpression operator()(ExpressionArray args,
-                                     PositionInfo pos = PositionInfo::Capture());
+                                     Position pos = {});
+
+    /**
+     * Invokes a prefix operator.
+     */
+    DSLExpression prefix(Operator::Kind op, Position pos);
+
+    /**
+     * Invokes a postfix operator.
+     */
+    DSLExpression postfix(Operator::Kind op, Position pos);
+
+    /**
+     * Invokes a binary operator.
+     */
+    DSLExpression binary(Operator::Kind op, DSLExpression right, Position pos);
+
+    /**
+     * Equivalent to operator[].
+     */
+    DSLExpression index(DSLExpression index, Position pos);
 
     /**
      * Returns true if this object contains an expression. DSLExpressions which were created with
@@ -216,12 +245,12 @@ 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 PositionInfo so that any pending errors can be
+ * 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 PositionInfo at the time of Expression construction (notably in operator overloads,
- * where we cannot add default parameters).
+ * capture the Position at the time of Expression construction (notably in operator overloads, where
+ * we cannot add default parameters).
  */
 class DSLPossibleExpression {
 public:
@@ -238,27 +267,31 @@ public:
     /**
      * Reports any pending errors at the specified position.
      */
-    void reportErrors(PositionInfo pos);
+    void reportErrors(Position pos);
+
+    DSLType type() const;
+
+    std::string description() const;
 
-    DSLType type();
+    Position position() const;
 
-    DSLExpression x(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression x(Position pos = {});
 
-    DSLExpression y(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression y(Position pos = {});
 
-    DSLExpression z(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression z(Position pos = {});
 
-    DSLExpression w(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression w(Position pos = {});
 
-    DSLExpression r(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression r(Position pos = {});
 
-    DSLExpression g(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression g(Position pos = {});
 
-    DSLExpression b(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression b(Position pos = {});
 
-    DSLExpression a(PositionInfo pos = PositionInfo::Capture());
+    DSLExpression a(Position pos = {});
 
-    DSLExpression field(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression field(std::string_view name, Position pos = {});
 
     DSLPossibleExpression operator=(DSLExpression expr);
 
@@ -271,10 +304,10 @@ public:
     DSLPossibleExpression operator[](DSLExpression index);
 
     DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
-                                     PositionInfo pos = PositionInfo::Capture());
+                                     Position pos = {});
 
     DSLPossibleExpression operator()(ExpressionArray args,
-                                     PositionInfo pos = PositionInfo::Capture());
+                                     Position pos = {});
 
     DSLPossibleExpression operator++();
 
@@ -284,7 +317,7 @@ public:
 
     DSLPossibleExpression operator--(int);
 
-    std::unique_ptr<SkSL::Expression> release(PositionInfo pos = PositionInfo::Capture());
+    std::unique_ptr<SkSL::Expression> release(Position pos = {});
 
 private:
     std::unique_ptr<SkSL::Expression> fExpression;

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

@@ -8,30 +8,35 @@
 #ifndef SKSL_DSL_FUNCTION
 #define SKSL_DSL_FUNCTION
 
+#include "include/private/SkSLDefines.h"
+#include "include/private/SkTArray.h"
 #include "include/sksl/DSLBlock.h"
 #include "include/sksl/DSLExpression.h"
-#include "include/sksl/DSLType.h"
+#include "include/sksl/DSLModifiers.h"
+#include "include/sksl/DSLStatement.h"
 #include "include/sksl/DSLVar.h"
-#include "include/sksl/DSLWrapper.h"
+#include "include/sksl/SkSLPosition.h"
+
+#include <string_view>
+#include <utility>
 
 namespace SkSL {
 
-class Block;
 class FunctionDeclaration;
-class Variable;
 
 namespace dsl {
 
 class DSLType;
+template <typename T> class DSLWrapper;
 
 class DSLFunction {
 public:
     template<class... Parameters>
-    DSLFunction(const DSLType& returnType, skstd::string_view name, Parameters&... parameters)
+    DSLFunction(const DSLType& returnType, std::string_view name, Parameters&... parameters)
         : DSLFunction(DSLModifiers(), returnType, name, parameters...) {}
 
     template<class... Parameters>
-    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, skstd::string_view name,
+    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, std::string_view name,
                 Parameters&... parameters) {
         SkTArray<DSLParameter*> parameterArray;
         parameterArray.reserve_back(sizeof...(parameters));
@@ -41,17 +46,17 @@ public:
         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 info from this overload.
-        this->init(modifiers, returnType, name, std::move(parameterArray), PositionInfo());
+        // unfortunately we can't capture position from this overload.
+        this->init(modifiers, returnType, name, std::move(parameterArray), Position());
     }
 
-    DSLFunction(const DSLType& returnType, skstd::string_view name,
-                SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
+    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, skstd::string_view name,
-                SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
+    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, std::string_view name,
+                SkTArray<DSLParameter*> parameters, Position pos = {}) {
         this->init(modifiers, returnType, name, std::move(parameters), pos);
     }
 
@@ -66,7 +71,7 @@ public:
         this->define(std::move(block));
     }
 
-    void define(DSLBlock block, PositionInfo pos = PositionInfo::Capture());
+    void define(DSLBlock block, Position pos = {});
 
     /**
      * Invokes the function with the given arguments.
@@ -83,9 +88,9 @@ public:
      * Invokes the function with the given arguments.
      */
     DSLExpression call(SkTArray<DSLWrapper<DSLExpression>> args,
-            PositionInfo pos = PositionInfo::Capture());
+            Position pos = {});
 
-    DSLExpression call(ExpressionArray args, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression call(ExpressionArray args, Position pos = {});
 
 private:
     void collectArgs(ExpressionArray& args) {}
@@ -102,11 +107,11 @@ private:
         collectArgs(args, std::forward<RemainingArgs>(remaining)...);
     }
 
-    void init(DSLModifiers modifiers, const DSLType& returnType, skstd::string_view name,
-              SkTArray<DSLParameter*> params, PositionInfo pos);
+    void init(DSLModifiers modifiers, const DSLType& returnType, std::string_view name,
+              SkTArray<DSLParameter*> params, Position pos);
 
     const SkSL::FunctionDeclaration* fDecl = nullptr;
-    SkSL::PositionInfo fPosition;
+    SkSL::Position fPosition;
 };
 
 } // namespace dsl

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

@@ -8,10 +8,8 @@
 #ifndef SKSL_DSL_LAYOUT
 #define SKSL_DSL_LAYOUT
 
-#include "include/sksl/DSLLayout.h"
-
 #include "include/private/SkSLLayout.h"
-#include "include/sksl/SkSLErrorReporter.h"
+#include "include/sksl/SkSLPosition.h"
 
 namespace SkSL {
 
@@ -21,53 +19,53 @@ class DSLLayout {
 public:
     DSLLayout() {}
 
-    DSLLayout& originUpperLeft(PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& originUpperLeft(Position pos = {}) {
         return this->flag(SkSL::Layout::kOriginUpperLeft_Flag, "origin_upper_left", pos);
     }
 
-    DSLLayout& pushConstant(PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& pushConstant(Position pos = {}) {
         return this->flag(SkSL::Layout::kPushConstant_Flag, "push_constant", pos);
     }
 
-    DSLLayout& blendSupportAllEquations(PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& blendSupportAllEquations(Position pos = {}) {
         return this->flag(SkSL::Layout::kBlendSupportAllEquations_Flag,
                           "blend_support_all_equations", pos);
     }
 
-    DSLLayout& color(PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& color(Position pos = {}) {
         return this->flag(SkSL::Layout::kColor_Flag, "color", pos);
     }
 
-    DSLLayout& location(int location, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& location(int location, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fLocation, location, SkSL::Layout::kLocation_Flag,
                               "location", pos);
     }
 
-    DSLLayout& offset(int offset, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& offset(int offset, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fOffset, offset, SkSL::Layout::kOffset_Flag, "offset",
                               pos);
     }
 
-    DSLLayout& binding(int binding, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& binding(int binding, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fBinding, binding, SkSL::Layout::kBinding_Flag,
                               "binding", pos);
     }
 
-    DSLLayout& index(int index, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& index(int index, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fIndex, index, SkSL::Layout::kIndex_Flag, "index", pos);
     }
 
-    DSLLayout& set(int set, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& set(int set, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fSet, set, SkSL::Layout::kSet_Flag, "set", pos);
     }
 
-    DSLLayout& builtin(int builtin, PositionInfo pos = PositionInfo::Capture()) {
+    DSLLayout& builtin(int builtin, Position pos = {}) {
         return this->intValue(&fSkSLLayout.fBuiltin, builtin, SkSL::Layout::kBuiltin_Flag,
                               "builtin", pos);
     }
 
     DSLLayout& inputAttachmentIndex(int inputAttachmentIndex,
-                                    PositionInfo pos = PositionInfo::Capture()) {
+                                    Position pos = {}) {
         return this->intValue(&fSkSLLayout.fInputAttachmentIndex, inputAttachmentIndex,
                               SkSL::Layout::kInputAttachmentIndex_Flag, "input_attachment_index",
                               pos);
@@ -77,10 +75,10 @@ private:
     explicit DSLLayout(SkSL::Layout skslLayout)
         : fSkSLLayout(skslLayout) {}
 
-    DSLLayout& flag(SkSL::Layout::Flag mask, const char* name, PositionInfo pos);
+    DSLLayout& flag(SkSL::Layout::Flag mask, const char* name, Position pos);
 
     DSLLayout& intValue(int* target, int value, SkSL::Layout::Flag flag, const char* name,
-                        PositionInfo pos);
+                        Position pos);
 
     SkSL::Layout fSkSLLayout;
 

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

@@ -32,11 +32,12 @@ enum Modifier {
 
 class DSLModifiers {
 public:
-    DSLModifiers(int flags = 0)
-        : DSLModifiers(DSLLayout(), flags) {}
+    DSLModifiers(int flags = 0, Position pos = {})
+        : DSLModifiers(DSLLayout(), flags, pos) {}
 
-    DSLModifiers(DSLLayout layout, int flags = 0)
-        : fModifiers(layout.fSkSLLayout, flags) {}
+    DSLModifiers(DSLLayout layout, int flags = 0, Position pos = {})
+        : fModifiers(layout.fSkSLLayout, flags)
+        , fPosition(pos) {}
 
     int flags() const {
         return fModifiers.fFlags;
@@ -48,8 +49,9 @@ public:
 
 private:
     SkSL::Modifiers fModifiers;
+    Position fPosition;
 
-    friend DSLType Struct(skstd::string_view name, SkSpan<DSLField> fields, PositionInfo pos);
+    friend DSLType Struct(std::string_view name, SkSpan<DSLField> fields, Position pos);
     friend class DSLCore;
     friend class DSLFunction;
     friend class DSLType;

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

@@ -8,8 +8,8 @@
 #ifndef SKSL_DSL_RUNTIME_EFFECTS
 #define SKSL_DSL_RUNTIME_EFFECTS
 
+#include "include/core/SkRefCnt.h"
 #include "include/effects/SkRuntimeEffect.h"
-#include "include/sksl/DSL.h"
 
 namespace SkSL {
 

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

@@ -8,19 +8,16 @@
 #ifndef SKSL_DSL_STATEMENT
 #define SKSL_DSL_STATEMENT
 
-#include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkSLStatement.h"
-#include "include/sksl/SkSLErrorReporter.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <memory>
-
-class GrGLSLShaderBuilder;
+#include <utility>
 
 namespace SkSL {
 
 class Expression;
-class Statement;
 
 namespace dsl {
 
@@ -28,7 +25,6 @@ class DSLBlock;
 class DSLExpression;
 class DSLPossibleExpression;
 class DSLPossibleStatement;
-class DSLVar;
 
 class DSLStatement {
 public:
@@ -36,9 +32,9 @@ public:
 
     DSLStatement(DSLExpression expr);
 
-    DSLStatement(DSLPossibleExpression expr, PositionInfo pos = PositionInfo::Capture());
+    DSLStatement(DSLPossibleExpression expr, Position pos = {});
 
-    DSLStatement(DSLPossibleStatement stmt, PositionInfo pos = PositionInfo::Capture());
+    DSLStatement(DSLPossibleStatement stmt, Position pos = {});
 
     DSLStatement(DSLBlock block);
 
@@ -52,6 +48,16 @@ public:
 
     DSLStatement& operator=(DSLStatement&& other) = default;
 
+    Position position() {
+        SkASSERT(this->hasValue());
+        return fStatement->fPosition;
+    }
+
+    void setPosition(Position pos) {
+        SkASSERT(this->hasValue());
+        fStatement->fPosition = pos;
+    }
+
     bool hasValue() { return fStatement != nullptr; }
 
     std::unique_ptr<SkSL::Statement> release() {
@@ -76,11 +82,11 @@ private:
 
 /**
  * Represents a Statement which may have failed and/or have pending errors to report. Converting a
- * PossibleStatement into a Statement requires PositionInfo so that any pending errors can be
+ * 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 PositionInfo at the time of Statement construction.
+ * the Position at the time of Statement construction.
  */
 class DSLPossibleStatement {
 public:

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

@@ -8,19 +8,19 @@
 #ifndef SKSL_DSL_SYMBOLS
 #define SKSL_DSL_SYMBOLS
 
-#include "include/core/SkStringView.h"
-#include "include/private/SkSLString.h"
 #include "include/sksl/DSLExpression.h"
 
 #include <memory>
+#include <string_view>
 
 namespace SkSL {
 
+class Position;
 class SymbolTable;
 
 namespace dsl {
 
-class DSLVar;
+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
@@ -47,22 +47,22 @@ std::shared_ptr<SymbolTable> CurrentSymbolTable();
 /**
  * Returns an expression referring to the named symbol.
  */
-DSLPossibleExpression Symbol(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+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(skstd::string_view name);
+bool IsType(std::string_view name);
 
 /**
  * Returns true if the name refers to a builtin type.
  */
-bool IsBuiltinType(skstd::string_view name);
+bool IsBuiltinType(std::string_view name);
 
 /**
  * Adds a variable to the current symbol table.
  */
-void AddToSymbolTable(DSLVarBase& var, PositionInfo pos = PositionInfo::Capture());
+void AddToSymbolTable(DSLVarBase& var, Position pos = {});
 
 } // namespace dsl