@shopify/react-native-skia 0.1.129 → 0.1.132

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

@@ -9,19 +9,21 @@
 #define SKSL_DSL_TYPE
 
 #include "include/core/SkSpan.h"
-#include "include/private/SkSLString.h"
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLModifiers.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <cstdint>
+#include <string_view>
+#include <utility>
 
 namespace SkSL {
 
+class Compiler;
 class Type;
 
 namespace dsl {
 
-class DSLExpression;
 class DSLField;
 class DSLVarBase;
 
@@ -80,16 +82,17 @@ enum TypeConstant : uint8_t {
 
 class DSLType {
 public:
-    DSLType(TypeConstant tc)
-        : fTypeConstant(tc) {}
+    DSLType(TypeConstant tc, Position pos = {})
+        : fTypeConstant(tc)
+        , fPosition(pos) {}
 
-    DSLType(const SkSL::Type* type);
+    DSLType(const SkSL::Type* type, Position pos = {});
 
-    DSLType(skstd::string_view name);
+    DSLType(std::string_view name, Position pos = {});
 
-    DSLType(skstd::string_view name,
+    DSLType(std::string_view name,
             DSLModifiers* modifiers,
-            PositionInfo pos = PositionInfo::Capture());
+            Position pos = {});
 
     /**
      * Returns true if this type is a bool.
@@ -169,15 +172,16 @@ private:
     const SkSL::Type& skslType() const;
 
     const SkSL::Type* fSkSLType = nullptr;
-
     TypeConstant fTypeConstant = kPoison_Type;
+    Position fPosition;
 
-    friend DSLType Array(const DSLType& base, int count, PositionInfo pos);
-    friend DSLType Struct(skstd::string_view name, SkSpan<DSLField> fields, PositionInfo pos);
+    friend DSLType Array(const DSLType& base, int count, Position pos);
+    friend DSLType Struct(std::string_view name, SkSpan<DSLField> fields, Position pos);
     friend class DSLCore;
     friend class DSLFunction;
     friend class DSLVarBase;
     friend class DSLWriter;
+    friend class SkSL::Compiler;
 };
 
 #define TYPE(T)                                                                                    \
@@ -218,16 +222,16 @@ MATRIX_TYPE(Half)
 #undef VECTOR_TYPE
 #undef MATRIX_TYPE
 
-DSLType Array(const DSLType& base, int count, PositionInfo pos = PositionInfo::Capture());
+DSLType Array(const DSLType& base, int count, Position pos = {});
 
 class DSLField {
 public:
-    DSLField(const DSLType type, skstd::string_view name,
-             PositionInfo pos = PositionInfo::Capture())
+    DSLField(const DSLType type, std::string_view name,
+             Position pos = {})
         : DSLField(DSLModifiers(), type, name, pos) {}
 
-    DSLField(const DSLModifiers& modifiers, const DSLType type, skstd::string_view name,
-             PositionInfo pos = PositionInfo::Capture())
+    DSLField(const DSLModifiers& modifiers, const DSLType type, std::string_view name,
+             Position pos = {})
         : fModifiers(modifiers)
         , fType(type)
         , fName(name)
@@ -236,20 +240,20 @@ public:
 private:
     DSLModifiers fModifiers;
     const DSLType fType;
-    skstd::string_view fName;
-    PositionInfo fPosition;
+    std::string_view fName;
+    Position fPosition;
 
     friend class DSLCore;
-    friend DSLType Struct(skstd::string_view name, SkSpan<DSLField> fields, PositionInfo pos);
+    friend DSLType Struct(std::string_view name, SkSpan<DSLField> fields, Position pos);
 };
 
-DSLType Struct(skstd::string_view name, SkSpan<DSLField> fields,
-               PositionInfo pos = PositionInfo::Capture());
+DSLType Struct(std::string_view name, SkSpan<DSLField> fields,
+               Position pos = {});
 
 template<typename... Field>
-DSLType Struct(skstd::string_view name, Field... fields) {
+DSLType Struct(std::string_view name, Field... fields) {
     DSLField fieldTypes[] = {std::move(fields)...};
-    return Struct(name, SkMakeSpan(fieldTypes), PositionInfo());
+    return Struct(name, SkMakeSpan(fieldTypes), Position());
 }
 
 } // namespace dsl

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

@@ -11,12 +11,20 @@
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLModifiers.h"
 #include "include/sksl/DSLType.h"
+#include "include/sksl/SkSLPosition.h"
+
+#include <stdint.h>
+#include <memory>
+#include <string_view>
+#include <utility>
 
 namespace SkSL {
 
 class Expression;
+class ExpressionArray;
 class IRGenerator;
 class SPIRVCodeGenerator;
+class Statement;
 class Variable;
 enum class VariableStorage : int8_t;
 
@@ -35,21 +43,22 @@ public:
      * name conflicts and the variable's name is only important when debugging shaders, the name
      * parameter is optional.
      */
-    DSLVarBase(DSLType type, skstd::string_view name, DSLExpression initialValue, PositionInfo pos);
+    DSLVarBase(DSLType type, std::string_view name, DSLExpression initialValue, Position pos,
+            Position namePos);
 
-    DSLVarBase(DSLType type, DSLExpression initialValue, PositionInfo pos);
+    DSLVarBase(DSLType type, DSLExpression initialValue, Position pos, Position namePos);
 
-    DSLVarBase(const DSLModifiers& modifiers, DSLType type, skstd::string_view name,
-               DSLExpression initialValue, PositionInfo pos);
+    DSLVarBase(const DSLModifiers& modifiers, DSLType type, std::string_view name,
+               DSLExpression initialValue, Position pos, Position namePos);
 
     DSLVarBase(const DSLModifiers& modifiers, DSLType type, DSLExpression initialValue,
-               PositionInfo pos);
+               Position pos, Position namePos);
 
     DSLVarBase(DSLVarBase&&) = default;
 
     virtual ~DSLVarBase();
 
-    skstd::string_view name() const {
+    std::string_view name() const {
         return fName;
     }
 
@@ -60,57 +69,57 @@ public:
     virtual VariableStorage storage() const = 0;
 
     DSLExpression x() {
-        return DSLExpression(*this, PositionInfo()).x();
+        return DSLExpression(*this, Position()).x();
     }
 
     DSLExpression y() {
-        return DSLExpression(*this, PositionInfo()).y();
+        return DSLExpression(*this, Position()).y();
     }
 
     DSLExpression z() {
-        return DSLExpression(*this, PositionInfo()).z();
+        return DSLExpression(*this, Position()).z();
     }
 
     DSLExpression w() {
-        return DSLExpression(*this, PositionInfo()).w();
+        return DSLExpression(*this, Position()).w();
     }
 
     DSLExpression r() {
-        return DSLExpression(*this, PositionInfo()).r();
+        return DSLExpression(*this, Position()).r();
     }
 
     DSLExpression g() {
-        return DSLExpression(*this, PositionInfo()).g();
+        return DSLExpression(*this, Position()).g();
     }
 
     DSLExpression b() {
-        return DSLExpression(*this, PositionInfo()).b();
+        return DSLExpression(*this, Position()).b();
     }
 
     DSLExpression a() {
-        return DSLExpression(*this, PositionInfo()).a();
+        return DSLExpression(*this, Position()).a();
     }
 
-    DSLExpression field(skstd::string_view name) {
-        return DSLExpression(*this, PositionInfo()).field(name);
+    DSLExpression field(std::string_view name) {
+        return DSLExpression(*this, Position()).field(name);
     }
 
     DSLPossibleExpression operator[](DSLExpression&& index);
 
     DSLPossibleExpression operator++() {
-        return ++DSLExpression(*this, PositionInfo());
+        return ++DSLExpression(*this, Position());
     }
 
     DSLPossibleExpression operator++(int) {
-        return DSLExpression(*this, PositionInfo())++;
+        return DSLExpression(*this, Position())++;
     }
 
     DSLPossibleExpression operator--() {
-        return --DSLExpression(*this, PositionInfo());
+        return --DSLExpression(*this, Position());
     }
 
     DSLPossibleExpression operator--(int) {
-        return DSLExpression(*this, PositionInfo())--;
+        return DSLExpression(*this, Position())--;
     }
 
 protected:
@@ -127,13 +136,14 @@ protected:
     int fUniformHandle = -1;
     std::unique_ptr<SkSL::Statement> fDeclaration;
     const SkSL::Variable* fVar = nullptr;
-    skstd::string_view fRawName; // for error reporting
-    skstd::string_view fName;
+    Position fNamePosition;
+    std::string_view fRawName; // for error reporting
+    std::string_view fName;
     DSLExpression fInitialValue;
     // true if we have attempted to create the SkSL var
     bool fInitialized = false;
     bool fDeclared = false;
-    PositionInfo fPosition;
+    Position fPosition;
 
     friend class DSLCore;
     friend class DSLExpression;
@@ -150,25 +160,25 @@ class DSLVar : public DSLVarBase {
 public:
     DSLVar() = default;
 
-    DSLVar(DSLType type, skstd::string_view name = "var",
+    DSLVar(DSLType type, std::string_view name = "var",
            DSLExpression initialValue = DSLExpression(),
-           PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(type, name, std::move(initialValue), pos) {}
+           Position pos = {}, Position namePos = {})
+        : INHERITED(type, name, std::move(initialValue), pos, namePos) {}
 
     DSLVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
-           PositionInfo pos = PositionInfo::Capture())
-        : DSLVar(type, skstd::string_view(name), std::move(initialValue), pos) {}
+           Position pos = {}, Position namePos = {})
+        : DSLVar(type, std::string_view(name), std::move(initialValue), pos, namePos) {}
 
-    DSLVar(DSLType type, DSLExpression initialValue, PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(type, std::move(initialValue), pos) {}
+    DSLVar(DSLType type, DSLExpression initialValue, Position pos = {}, Position namePos = {})
+        : INHERITED(type, std::move(initialValue), pos, namePos) {}
 
-    DSLVar(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(modifiers, type, name, std::move(initialValue), pos) {}
+    DSLVar(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
+        : INHERITED(modifiers, type, name, std::move(initialValue), pos, namePos) {}
 
     DSLVar(const DSLModifiers& modifiers, DSLType type, const char* name,
-           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
-        : DSLVar(modifiers, type, skstd::string_view(name), std::move(initialValue), pos) {}
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
+        : DSLVar(modifiers, type, std::string_view(name), std::move(initialValue), pos, namePos) {}
 
     DSLVar(DSLVar&&) = default;
 
@@ -198,25 +208,26 @@ class DSLGlobalVar : public DSLVarBase {
 public:
     DSLGlobalVar() = default;
 
-    DSLGlobalVar(DSLType type, skstd::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(type, name, std::move(initialValue), pos) {}
+    DSLGlobalVar(DSLType type, std::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
+        : INHERITED(type, name, std::move(initialValue), pos, namePos) {}
 
     DSLGlobalVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
-                 PositionInfo pos = PositionInfo::Capture())
-        : DSLGlobalVar(type, skstd::string_view(name), std::move(initialValue), pos) {}
+                 Position pos = {}, Position namePos = {})
+        : DSLGlobalVar(type, std::string_view(name), std::move(initialValue), pos, namePos) {}
 
     DSLGlobalVar(DSLType type, DSLExpression initialValue,
-                 PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(type, std::move(initialValue), pos) {}
+                 Position pos = {}, Position namePos = {})
+        : INHERITED(type, std::move(initialValue), pos, namePos) {}
 
-    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(modifiers, type, name, std::move(initialValue), pos) {}
+    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
+        : INHERITED(modifiers, type, name, std::move(initialValue), pos, namePos) {}
 
     DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, const char* name,
-           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
-        : DSLGlobalVar(modifiers, type, skstd::string_view(name), std::move(initialValue), pos) {}
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
+        : DSLGlobalVar(modifiers, type, std::string_view(name), std::move(initialValue), pos,
+                       namePos) {}
 
     DSLGlobalVar(const char* name);
 
@@ -242,19 +253,19 @@ public:
      *     half4 shader::eval(float2 coords);
      *     half4 colorFilter::eval(half4 input);
      */
-    DSLExpression eval(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+    DSLExpression eval(DSLExpression x, Position pos = {});
 
     /**
      * Implements the following method call:
      *     half4 blender::eval(half4 src, half4 dst);
      */
     DSLExpression eval(DSLExpression x, DSLExpression y,
-            PositionInfo pos = PositionInfo::Capture());
+            Position pos = {});
 
 private:
-    DSLExpression eval(ExpressionArray args, PositionInfo pos);
+    DSLExpression eval(ExpressionArray args, Position pos);
 
-    std::unique_ptr<SkSL::Expression> methodCall(skstd::string_view methodName, PositionInfo pos);
+    std::unique_ptr<SkSL::Expression> methodCall(std::string_view methodName, Position pos);
 
     using INHERITED = DSLVarBase;
 };
@@ -266,20 +277,20 @@ class DSLParameter : public DSLVarBase {
 public:
     DSLParameter() = default;
 
-    DSLParameter(DSLType type, skstd::string_view name = "var",
-                 PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(type, name, DSLExpression(), pos) {}
+    DSLParameter(DSLType type, std::string_view name = "var",
+                 Position pos = {}, Position namePos = {})
+        : INHERITED(type, name, DSLExpression(), pos, namePos) {}
 
-    DSLParameter(DSLType type, const char* name, PositionInfo pos = PositionInfo::Capture())
-        : DSLParameter(type, skstd::string_view(name), pos) {}
+    DSLParameter(DSLType type, const char* name, Position pos = {}, Position namePos = {})
+        : DSLParameter(type, std::string_view(name), pos, namePos) {}
 
-    DSLParameter(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
-                 PositionInfo pos = PositionInfo::Capture())
-        : INHERITED(modifiers, type, name, DSLExpression(), pos) {}
+    DSLParameter(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
+                 Position pos = {}, Position namePos = {})
+        : INHERITED(modifiers, type, name, DSLExpression(), pos, namePos) {}
 
     DSLParameter(const DSLModifiers& modifiers, DSLType type, const char* name,
-                 PositionInfo pos = PositionInfo::Capture())
-        : DSLParameter(modifiers, type, skstd::string_view(name), pos) {}
+                 Position pos = {}, Position namePos = {})
+        : DSLParameter(modifiers, type, std::string_view(name), pos, namePos) {}
 
     DSLParameter(DSLParameter&&) = default;
 

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

@@ -8,45 +8,15 @@
 #ifndef SKSL_ERROR_REPORTER
 #define SKSL_ERROR_REPORTER
 
-#include "include/core/SkStringView.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkSLString.h"
 
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace SkSL {
 
-#ifndef __has_builtin
-    #define __has_builtin(x) 0
-#endif
-
-class PositionInfo {
-public:
-    PositionInfo(const char* file = nullptr, int line = -1)
-        : fFile(file)
-        , fLine(line) {}
-
-#if __has_builtin(__builtin_FILE) && __has_builtin(__builtin_LINE)
-    static PositionInfo Capture(const char* file = __builtin_FILE(), int line = __builtin_LINE()) {
-        return PositionInfo(file, line);
-    }
-#else
-    static PositionInfo Capture() { return PositionInfo(); }
-#endif // __has_builtin(__builtin_FILE) && __has_builtin(__builtin_LINE)
-
-    const char* file_name() const {
-        return fFile;
-    }
-
-    int line() const {
-        return fLine;
-    }
-
-private:
-    const char* fFile = nullptr;
-    int32_t fLine = -1;
-};
+class Position;
 
 /**
  * Class which is notified in the event of an error.
@@ -59,24 +29,19 @@ public:
         SkASSERT(fPendingErrors.empty());
     }
 
-    void error(skstd::string_view msg, PositionInfo position);
+    void error(std::string_view msg, Position position);
 
     /**
      * Reports an error message at the given line of the source text. Errors reported
      * with a line of -1 will be queued until line number information can be determined.
      */
-    void error(int line, skstd::string_view msg);
+    void error(Position pos, std::string_view msg);
 
-    const char* source() const { return fSource; }
+    std::string_view source() const { return fSource; }
 
-    void setSource(const char* source) { fSource = source; }
+    void setSource(std::string_view source) { fSource = source; }
 
-    void reportPendingErrors(PositionInfo pos) {
-        for (const String& msg : fPendingErrors) {
-            this->handleError(msg, pos);
-        }
-        fPendingErrors.clear();
-    }
+    void reportPendingErrors(Position pos);
 
     int errorCount() const {
         return fErrorCount;
@@ -90,13 +55,13 @@ protected:
     /**
      * Called when an error is reported.
      */
-    virtual void handleError(skstd::string_view msg, PositionInfo position) = 0;
+    virtual void handleError(std::string_view msg, Position position) = 0;
 
 private:
-    PositionInfo position(int offset) const;
+    Position position(int offset) const;
 
-    const char* fSource = nullptr;
-    std::vector<String> fPendingErrors;
+    std::string_view fSource;
+    std::vector<std::string> fPendingErrors;
     int fErrorCount = 0;
 };
 
@@ -105,9 +70,7 @@ private:
  */
 class TestingOnly_AbortErrorReporter : public ErrorReporter {
 public:
-    void handleError(skstd::string_view msg, PositionInfo pos) override {
-        SK_ABORT("%.*s", (int)msg.length(), msg.data());
-    }
+    void handleError(std::string_view msg, Position pos) override;
 };
 
 } // namespace SkSL

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

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKSL_OPERATOR
+#define SKSL_OPERATOR
+
+#include <string_view>
+
+namespace SkSL {
+
+class Context;
+class Type;
+
+class Operator {
+public:
+    enum class Kind {
+        PLUS,
+        MINUS,
+        STAR,
+        SLASH,
+        PERCENT,
+        SHL,
+        SHR,
+        LOGICALNOT,
+        LOGICALAND,
+        LOGICALOR,
+        LOGICALXOR,
+        BITWISENOT,
+        BITWISEAND,
+        BITWISEOR,
+        BITWISEXOR,
+        EQ,
+        EQEQ,
+        NEQ,
+        LT,
+        GT,
+        LTEQ,
+        GTEQ,
+        PLUSEQ,
+        MINUSEQ,
+        STAREQ,
+        SLASHEQ,
+        PERCENTEQ,
+        SHLEQ,
+        SHREQ,
+        BITWISEANDEQ,
+        BITWISEOREQ,
+        BITWISEXOREQ,
+        PLUSPLUS,
+        MINUSMINUS,
+        COMMA
+    };
+
+    enum class Precedence {
+        kParentheses    =  1,
+        kPostfix        =  2,
+        kPrefix         =  3,
+        kMultiplicative =  4,
+        kAdditive       =  5,
+        kShift          =  6,
+        kRelational     =  7,
+        kEquality       =  8,
+        kBitwiseAnd     =  9,
+        kBitwiseXor     = 10,
+        kBitwiseOr      = 11,
+        kLogicalAnd     = 12,
+        kLogicalXor     = 13,
+        kLogicalOr      = 14,
+        kTernary        = 15,
+        kAssignment     = 16,
+        kSequence       = 17,
+        kTopLevel       = kSequence
+    };
+
+    Operator(Kind op) : fKind(op) {}
+
+    Kind kind() const { return fKind; }
+
+    bool isEquality() const {
+        return fKind == Kind::EQEQ || fKind == Kind::NEQ;
+    }
+
+    Precedence getBinaryPrecedence() const;
+
+    // Returns the operator name surrounded by the expected whitespace for a tidy binary expression.
+    const char* operatorName() const;
+
+    // Returns the operator name without any surrounding whitespace.
+    std::string_view tightOperatorName() const;
+
+    // Returns true if op is '=' or any compound assignment operator ('+=', '-=', etc.)
+    bool isAssignment() const;
+
+    // Given a compound assignment operator, returns the non-assignment version of the operator
+    // (e.g. '+=' becomes '+')
+    Operator removeAssignment() const;
+
+    /**
+     * Defines the set of relational (comparison) operators:
+     *     <  <=  >  >=
+     */
+    bool isRelational() const;
+
+    /**
+     * Defines the set of operators which are only valid on integral types:
+     *   <<  <<=  >>  >>=  &  &=  |  |=  ^  ^=  %  %=
+     */
+    bool isOnlyValidForIntegralTypes() const;
+
+    /**
+     * Defines the set of operators which perform vector/matrix math.
+     *   +  +=  -  -=  *  *=  /  /=  %  %=  <<  <<=  >>  >>=  &  &=  |  |=  ^  ^=
+     */
+    bool isValidForMatrixOrVector() const;
+
+    /*
+     * Defines the set of operators allowed by The OpenGL ES Shading Language 1.00, Section 5.1.
+     * The set of illegal (reserved) operators are the ones that only make sense with integral
+     * types. This is not a coincidence: It's because ES2 doesn't require 'int' to be anything but
+     * syntactic sugar for floats with truncation after each operation.
+     */
+    bool isAllowedInStrictES2Mode() const {
+        return !this->isOnlyValidForIntegralTypes();
+    }
+
+    /**
+     * Determines the operand and result types of a binary expression. Returns true if the
+     * expression is legal, false otherwise. If false, the values of the out parameters are
+     * undefined.
+     */
+    bool determineBinaryType(const Context& context,
+                             const Type& left,
+                             const Type& right,
+                             const Type** outLeftType,
+                             const Type** outRightType,
+                             const Type** outResultType) const;
+
+private:
+    bool isOperator() const;
+    bool isMatrixMultiply(const Type& left, const Type& right) const;
+
+    Kind fKind;
+};
+
+}  // namespace SkSL
+
+#endif