@shopify/react-native-skia 0.1.128 → 0.1.131

package/cpp/skia/include/gpu/graphite/TextureInfo.h

@@ -0,0 +1,91 @@
+/*
+ * 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 skgpu_graphite_TextureInfo_DEFINED
+#define skgpu_graphite_TextureInfo_DEFINED
+
+#include "include/gpu/graphite/GraphiteTypes.h"
+
+#ifdef SK_METAL
+#include "include/private/gpu/graphite/MtlTypesPriv.h"
+#endif
+
+namespace skgpu::graphite {
+
+// Forward declares so we can friend classes in other namespaces
+#ifdef SK_METAL
+namespace graphite {
+    class MtlCaps;
+    class MtlTexture;
+}
+#endif
+
+class TextureInfo {
+public:
+    TextureInfo() {}
+#ifdef SK_METAL
+    TextureInfo(const MtlTextureInfo& mtlInfo)
+            : fBackend(BackendApi::kMetal)
+            , fValid(true)
+            , fSampleCount(mtlInfo.fSampleCount)
+            , fLevelCount(mtlInfo.fLevelCount)
+            , fProtected(Protected::kNo)
+            , fMtlSpec(mtlInfo) {}
+#endif
+
+    ~TextureInfo() {}
+    TextureInfo(const TextureInfo&) = default;
+    TextureInfo& operator=(const TextureInfo&);
+
+    bool operator==(const TextureInfo&) const;
+    bool operator!=(const TextureInfo& that) const { return !(*this == that); }
+
+    bool isValid() const { return fValid; }
+    BackendApi backend() const { return fBackend; }
+
+    uint32_t numSamples() const { return fSampleCount; }
+    uint32_t numMipLevels() const { return fLevelCount; }
+    Protected isProtected() const { return fProtected; }
+
+#ifdef SK_METAL
+    bool getMtlTextureInfo(MtlTextureInfo* info) const {
+        if (!this->isValid() || fBackend != BackendApi::kMetal) {
+            return false;
+        }
+        *info = MtlTextureSpecToTextureInfo(fMtlSpec, fSampleCount, fLevelCount);
+        return true;
+    }
+#endif
+
+private:
+#ifdef SK_METAL
+    friend class MtlCaps;
+    friend class MtlGraphicsPipeline;
+    friend class MtlTexture;
+    const MtlTextureSpec& mtlTextureSpec() const {
+        SkASSERT(fValid && fBackend == BackendApi::kMetal);
+        return fMtlSpec;
+    }
+#endif
+
+    BackendApi fBackend = BackendApi::kMock;
+    bool fValid = false;
+
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    Protected fProtected = Protected::kNo;
+
+    union {
+#ifdef SK_METAL
+        MtlTextureSpec fMtlSpec;
+#endif
+    };
+};
+
+}  // namespace skgpu::graphite
+
+#endif  //skgpu_graphite_TextureInfo_DEFINED

package/cpp/skia/include/gpu/graphite/mtl/MtlBackendContext.h

@@ -0,0 +1,24 @@
+/*
+ * 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 skgpu_graphite_MtlBackendContext_DEFINED
+#define skgpu_graphite_MtlBackendContext_DEFINED
+
+#include "include/gpu/graphite/mtl/MtlTypes.h"
+
+namespace skgpu::graphite {
+
+// The MtlBackendContext contains all of the base Metal objects needed by the MtlGpu. The assumption
+// is that the client will set these up and pass them to the MtlGpu constructor.
+struct SK_API MtlBackendContext {
+    sk_cfp<CFTypeRef> fDevice;
+    sk_cfp<CFTypeRef> fQueue;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_MtlBackendContext_DEFINED

package/cpp/skia/include/gpu/graphite/mtl/MtlTypes.h

@@ -0,0 +1,68 @@
+/*
+ * 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 skgpu_graphite_MtlTypes_DEFINED
+#define skgpu_graphite_MtlTypes_DEFINED
+
+#include "include/ports/SkCFObject.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __APPLE__
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <TargetConditionals.h>
+
+#if TARGET_OS_SIMULATOR
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0))
+#else  // TARGET_OS_SIMULATOR
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0))
+#endif  // TARGET_OS_SIMULATOR
+
+#endif // __APPLE__
+
+
+namespace skgpu::graphite {
+
+/**
+ * Declares typedefs for Metal types used in Graphite cpp code
+ */
+using MtlPixelFormat = unsigned int;
+using MtlTextureUsage = unsigned int;
+using MtlStorageMode = unsigned int;
+using MtlHandle = const void*;
+
+struct MtlTextureInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+
+    // Since we aren't in an Obj-C header we can't directly use Mtl types here. Each of these can
+    // cast to their mapped Mtl types list below.
+    MtlPixelFormat fFormat = 0;       // MTLPixelFormat fFormat = MTLPixelFormatInvalid;
+    MtlTextureUsage fUsage = 0;       // MTLTextureUsage fUsage = MTLTextureUsageUnknown;
+    MtlStorageMode fStorageMode = 0;  // MTLStorageMode fStorageMode = MTLStorageModeShared;
+    bool fFramebufferOnly = false;
+
+    MtlTextureInfo() = default;
+    MtlTextureInfo(MtlHandle mtlTexture);
+    MtlTextureInfo(uint32_t sampleCount,
+                   uint32_t levelCount,
+                   MtlPixelFormat format,
+                   MtlTextureUsage usage,
+                   MtlStorageMode storageMode,
+                   bool framebufferOnly)
+            : fSampleCount(sampleCount)
+            , fLevelCount(levelCount)
+            , fFormat(format)
+            , fUsage(usage)
+            , fStorageMode(storageMode)
+            , fFramebufferOnly(framebufferOnly) {}
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_MtlTypes_DEFINED

package/cpp/skia/include/gpu/mock/GrMockTypes.h

@@ -9,7 +9,7 @@
 #define GrMockOptions_DEFINED
 
 #include "include/gpu/GrTypes.h"
-#include "include/private/GrTypesPriv.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
 
 class GrBackendFormat;
 
@@ -125,7 +125,6 @@ struct GrMockOptions {
     int fMaxRenderTargetSize = 2048;
     int fMaxWindowRectangles = 0;
     int fMaxVertexAttributes = 16;
-    int fMaxTessellationSegments = 0;
     ConfigOptions fConfigOptions[kGrColorTypeCnt];
     ConfigOptions fCompressedOptions[SkImage::kCompressionTypeCount];
 

package/cpp/skia/include/ports/SkCFObject.h

@@ -176,9 +176,5 @@ template <typename T> sk_cfp<T> sk_ret_cfp(T obj) {
     return sk_cfp<T>(SkCFSafeRetain(obj));
 }
 
-// For Flutter.
-// TODO: migrate them away from this and remove
-template <typename T> using sk_cf_obj = sk_cfp<T>;
-
 #endif  // __APPLE__
 #endif  // SkCFObject_DEFINED

package/cpp/skia/include/ports/SkTypeface_win.h

@@ -53,8 +53,8 @@ struct IDWriteFontCollection;
 struct IDWriteFontFallback;
 
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_GDI();
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory = NULL,
-                                                  IDWriteFontCollection* collection = NULL);
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory = nullptr,
+                                                  IDWriteFontCollection* collection = nullptr);
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory,
                                                   IDWriteFontCollection* collection,
                                                   IDWriteFontFallback* fallback);

package/cpp/skia/include/private/SingleOwner.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_SingleOwner_DEFINED
+#define skgpu_SingleOwner_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#ifdef SK_DEBUG
+#include "include/private/SkMutex.h"
+#include "include/private/SkThreadID.h"
+#endif
+
+namespace skgpu {
+
+#ifdef SK_DEBUG
+
+#define SKGPU_ASSERT_SINGLE_OWNER(obj) \
+    skgpu::SingleOwner::AutoEnforce debug_SingleOwner(obj, __FILE__, __LINE__);
+
+// This is a debug tool to verify an object is only being used from one thread at a time.
+class SingleOwner {
+public:
+     SingleOwner() : fOwner(kIllegalThreadID), fReentranceCount(0) {}
+
+     struct AutoEnforce {
+         AutoEnforce(SingleOwner* so, const char* file, int line)
+                : fFile(file), fLine(line), fSO(so) {
+             fSO->enter(file, line);
+         }
+         ~AutoEnforce() { fSO->exit(fFile, fLine); }
+
+         const char* fFile;
+         int fLine;
+         SingleOwner* fSO;
+     };
+
+private:
+     void enter(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkThreadID self = SkGetThreadID();
+         SkASSERTF(fOwner == self || fOwner == kIllegalThreadID, "%s:%d Single owner failure.",
+                   file, line);
+         fReentranceCount++;
+         fOwner = self;
+     }
+
+     void exit(const char* file, int line) {
+         SkAutoMutexExclusive lock(fMutex);
+         SkASSERTF(fOwner == SkGetThreadID(), "%s:%d Single owner failure.", file, line);
+         fReentranceCount--;
+         if (fReentranceCount == 0) {
+             fOwner = kIllegalThreadID;
+         }
+     }
+
+     SkMutex fMutex;
+     SkThreadID fOwner    SK_GUARDED_BY(fMutex);
+     int fReentranceCount SK_GUARDED_BY(fMutex);
+};
+#else
+#define SKGPU_ASSERT_SINGLE_OWNER(obj)
+class SingleOwner {}; // Provide a no-op implementation so we can pass pointers to constructors
+#endif
+
+} // namespace skgpu
+
+#endif

package/cpp/skia/include/private/SkChecksum.h

@@ -14,6 +14,9 @@
 #include "include/private/SkOpts_spi.h"
 #include "include/private/SkTLogic.h"
 
+#include <string>
+#include <string_view>
+
 class SkChecksum : SkNoncopyable {
 public:
     /**
@@ -61,6 +64,14 @@ struct SkGoodHash {
     uint32_t operator()(const SkString& k) const {
         return SkOpts::hash_fn(k.c_str(), k.size(), 0);
     }
+
+    uint32_t operator()(const std::string& k) const {
+        return SkOpts::hash_fn(k.c_str(), k.size(), 0);
+    }
+
+    uint32_t operator()(std::string_view k) const {
+        return SkOpts::hash_fn(k.data(), k.size(), 0);
+    }
 };
 
 #endif

package/cpp/skia/include/private/SkEncodedInfo.h

@@ -10,6 +10,7 @@
 
 #include <memory>
 
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkData.h"
 #include "include/core/SkImageInfo.h"
 #include "include/third_party/skcms/skcms.h"
@@ -100,8 +101,15 @@ public:
         return Make(width, height, color, alpha, bitsPerComponent, nullptr);
     }
 
-    static SkEncodedInfo Make(int width, int height, Color color, Alpha alpha,
-            int bitsPerComponent, std::unique_ptr<ICCProfile> profile) {
+    static SkEncodedInfo Make(int width, int height, Color color,
+            Alpha alpha, int bitsPerComponent, std::unique_ptr<ICCProfile> profile) {
+        return Make(width, height, color, alpha, /*bitsPerComponent*/ bitsPerComponent,
+                std::move(profile), /*colorDepth*/ bitsPerComponent);
+    }
+
+    static SkEncodedInfo Make(int width, int height, Color color,
+            Alpha alpha, int bitsPerComponent, std::unique_ptr<ICCProfile> profile,
+            int colorDepth) {
         SkASSERT(1 == bitsPerComponent ||
                  2 == bitsPerComponent ||
                  4 == bitsPerComponent ||
@@ -150,7 +158,8 @@ public:
                 break;
         }
 
-        return SkEncodedInfo(width, height, color, alpha, bitsPerComponent, std::move(profile));
+        return SkEncodedInfo(width, height, color, alpha,
+                bitsPerComponent, colorDepth, std::move(profile));
     }
 
     /*
@@ -220,21 +229,28 @@ public:
 
     // Explicit copy method, to avoid accidental copying.
     SkEncodedInfo copy() const {
-        auto copy = SkEncodedInfo::Make(fWidth, fHeight, fColor, fAlpha, fBitsPerComponent);
+        auto copy = SkEncodedInfo::Make(
+                fWidth, fHeight, fColor, fAlpha, fBitsPerComponent, nullptr, fColorDepth);
         if (fProfile) {
             copy.fProfile = std::make_unique<ICCProfile>(*fProfile);
         }
         return copy;
     }
 
+    // Return number of bits of R/G/B channel
+    uint8_t getColorDepth() const {
+        return fColorDepth;
+    }
+
 private:
     SkEncodedInfo(int width, int height, Color color, Alpha alpha,
-            uint8_t bitsPerComponent, std::unique_ptr<ICCProfile> profile)
+            uint8_t bitsPerComponent, uint8_t colorDepth, std::unique_ptr<ICCProfile> profile)
         : fWidth(width)
         , fHeight(height)
         , fColor(color)
         , fAlpha(alpha)
         , fBitsPerComponent(bitsPerComponent)
+        , fColorDepth(colorDepth)
         , fProfile(std::move(profile))
     {}
 
@@ -243,6 +259,7 @@ private:
     Color                       fColor;
     Alpha                       fAlpha;
     uint8_t                     fBitsPerComponent;
+    uint8_t                     fColorDepth;
     std::unique_ptr<ICCProfile> fProfile;
 };
 

package/cpp/skia/include/private/SkFloatingPoint.h

@@ -17,15 +17,6 @@
 #include <cstring>
 #include <limits>
 
-
-#if defined(SK_LEGACY_FLOAT_RSQRT)
-#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
-    #include <xmmintrin.h>
-#elif defined(SK_ARM_HAS_NEON)
-    #include <arm_neon.h>
-#endif
-#endif
-
 constexpr float SK_FloatSqrt2 = 1.41421356f;
 constexpr float SK_FloatPI    = 3.14159265f;
 constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
@@ -171,53 +162,9 @@ static inline float sk_double_to_float(double x) {
 // Returns true if count is 0
 bool sk_floats_are_unit(const float array[], size_t count);
 
-#if defined(SK_LEGACY_FLOAT_RSQRT)
-static inline float sk_float_rsqrt_portable(float x) {
-    // Get initial estimate.
-    int i;
-    memcpy(&i, &x, 4);
-    i = 0x5F1FFFF9 - (i>>1);
-    float estimate;
-    memcpy(&estimate, &i, 4);
-
-    // One step of Newton's method to refine.
-    const float estimate_sq = estimate*estimate;
-    estimate *= 0.703952253f*(2.38924456f-x*estimate_sq);
-    return estimate;
-}
-
-// Fast, approximate inverse square root.
-// Compare to name-brand "1.0f / sk_float_sqrt(x)".  Should be around 10x faster on SSE, 2x on NEON.
-static inline float sk_float_rsqrt(float x) {
-// We want all this inlined, so we'll inline SIMD and just take the hit when we don't know we've got
-// it at compile time.  This is going to be too fast to productively hide behind a function pointer.
-//
-// We do one step of Newton's method to refine the estimates in the NEON and portable paths.  No
-// refinement is faster, but very innacurate.  Two steps is more accurate, but slower than 1/sqrt.
-//
-// Optimized constants in the portable path courtesy of http://rrrola.wz.cz/inv_sqrt.html
-#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE1
-    return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x)));
-#elif defined(SK_ARM_HAS_NEON)
-    // Get initial estimate.
-    const float32x2_t xx = vdup_n_f32(x);  // Clever readers will note we're doing everything 2x.
-    float32x2_t estimate = vrsqrte_f32(xx);
-
-    // One step of Newton's method to refine.
-    const float32x2_t estimate_sq = vmul_f32(estimate, estimate);
-    estimate = vmul_f32(estimate, vrsqrts_f32(xx, estimate_sq));
-    return vget_lane_f32(estimate, 0);  // 1 will work fine too; the answer's in both places.
-#else
-    return sk_float_rsqrt_portable(x);
-#endif
-}
-#else
-
 static inline float sk_float_rsqrt_portable(float x) { return 1.0f / sk_float_sqrt(x); }
 static inline float sk_float_rsqrt         (float x) { return 1.0f / sk_float_sqrt(x); }
 
-#endif
-
 // Returns the log2 of the provided value, were that value to be rounded up to the next power of 2.
 // Returns 0 if value <= 0:
 // Never returns a negative number, even if value is NaN.

package/cpp/skia/include/private/SkImageInfoPriv.h

@@ -35,6 +35,7 @@ static inline uint32_t SkColorTypeChannelFlags(SkColorType ct) {
         case kR16G16_float_SkColorType:       return kRG_SkColorChannelFlags;
         case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorChannelFlags;
         case kSRGBA_8888_SkColorType:         return kRGBA_SkColorChannelFlags;
+        case kR8_unorm_SkColorType:           return kRed_SkColorChannelFlag;
     }
     SkUNREACHABLE;
 }
@@ -71,6 +72,7 @@ static int SkColorTypeShiftPerPixel(SkColorType ct) {
         case kR16G16_float_SkColorType:       return 2;
         case kR16G16B16A16_unorm_SkColorType: return 3;
         case kSRGBA_8888_SkColorType:         return 2;
+        case kR8_unorm_SkColorType:           return 0;
     }
     SkUNREACHABLE;
 }
@@ -110,11 +112,14 @@ static inline bool SkColorTypeIsNormalized(SkColorType ct) {
         case kA16_float_SkColorType:          /*subtle... alpha is always [0,1]*/
         case kR16G16_unorm_SkColorType:
         case kR16G16B16A16_unorm_SkColorType:
-        case kSRGBA_8888_SkColorType: return true;
+        case kSRGBA_8888_SkColorType:
+        case kR8_unorm_SkColorType:
+            return true;
 
         case kRGBA_F16_SkColorType:
         case kRGBA_F32_SkColorType:
-        case kR16G16_float_SkColorType:       return false;
+        case kR16G16_float_SkColorType:
+            return false;
     }
     SkUNREACHABLE;
 }
@@ -137,6 +142,7 @@ static inline int SkColorTypeMaxBitsPerChannel(SkColorType ct) {
         case kGray_8_SkColorType:
         case kR8G8_unorm_SkColorType:
         case kSRGBA_8888_SkColorType:
+        case kR8_unorm_SkColorType:
             return 8;
 
         case kRGBA_1010102_SkColorType:

package/cpp/skia/include/private/SkMacros.h

@@ -7,6 +7,8 @@
 #ifndef SkMacros_DEFINED
 #define SkMacros_DEFINED
 
+#include <type_traits>
+
 /*
  *  Usage:  SK_MACRO_CONCAT(a, b)   to construct the symbol ab
  *
@@ -47,38 +49,31 @@
  * bitfield.
  */
 #define SK_MAKE_BITFIELD_OPS(X) \
+    inline X operator ~(X a) { \
+        using U = std::underlying_type_t<X>; \
+        return (X) (~static_cast<U>(a)); \
+    } \
     inline X operator |(X a, X b) { \
-        return (X) (+a | +b); \
+        using U = std::underlying_type_t<X>; \
+        return (X) (static_cast<U>(a) | static_cast<U>(b)); \
     } \
     inline X& operator |=(X& a, X b) { \
         return (a = a | b); \
     } \
     inline X operator &(X a, X b) { \
-        return (X) (+a & +b); \
+        using U = std::underlying_type_t<X>; \
+        return (X) (static_cast<U>(a) & static_cast<U>(b)); \
     } \
     inline X& operator &=(X& a, X b) { \
         return (a = a & b); \
-    } \
-    template <typename T> \
-    inline X operator &(T a, X b) { \
-        return (X) (+a & +b); \
-    } \
-    template <typename T> \
-    inline X operator &(X a, T b) { \
-        return (X) (+a & +b); \
-    } \
+    }
 
 #define SK_DECL_BITFIELD_OPS_FRIENDS(X) \
+    friend X operator ~(X a); \
     friend X operator |(X a, X b); \
     friend X& operator |=(X& a, X b); \
     \
     friend X operator &(X a, X b); \
-    friend X& operator &=(X& a, X b); \
-    \
-    template <typename T> \
-    friend X operator &(T a, X b); \
-    \
-    template <typename T> \
-    friend X operator &(X a, T b); \
+    friend X& operator &=(X& a, X b);
 
 #endif  // SkMacros_DEFINED

package/cpp/skia/include/private/SkMutex.h

@@ -18,6 +18,10 @@ class SK_CAPABILITY("mutex") SkMutex {
 public:
     constexpr SkMutex() = default;
 
+    ~SkMutex() {
+        this->assertNotHeld();
+    }
+
     void acquire() SK_ACQUIRE() {
         fSemaphore.wait();
         SkDEBUGCODE(fOwner = SkGetThreadID();)
@@ -33,6 +37,10 @@ public:
         SkASSERT(fOwner == SkGetThreadID());
     }
 
+    void assertNotHeld() {
+        SkASSERT(fOwner == kIllegalThreadID);
+    }
+
 private:
     SkSemaphore fSemaphore{1};
     SkDEBUGCODE(SkThreadID fOwner{kIllegalThreadID};)

package/cpp/skia/include/private/SkPathRef.h

@@ -10,7 +10,6 @@
 
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPoint.h"
-#include "include/core/SkRRect.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkIDChangeListener.h"
@@ -25,6 +24,7 @@
 
 class SkRBuffer;
 class SkWBuffer;
+class SkRRect;
 
 enum class SkPathConvexity {
     kConvex,
@@ -246,21 +246,7 @@ public:
         return SkToBool(fIsOval);
     }
 
-    bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const {
-        if (fIsRRect) {
-            if (rrect) {
-                *rrect = this->getRRect();
-            }
-            if (isCCW) {
-                *isCCW = SkToBool(fRRectOrOvalIsCCW);
-            }
-            if (start) {
-                *start = fRRectOrOvalStartIdx;
-            }
-        }
-        return SkToBool(fIsRRect);
-    }
-
+    bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const;
 
     bool hasComputedBounds() const {
         return !fBoundsIsDirty;

package/cpp/skia/include/private/SkSLDefines.h

@@ -22,7 +22,15 @@ class Expression;
 class Statement;
 
 using ComponentArray = SkSTArray<4, int8_t>; // for Swizzles
-using ExpressionArray = SkSTArray<2, std::unique_ptr<Expression>>;
+
+class ExpressionArray : public SkSTArray<2, std::unique_ptr<Expression>> {
+public:
+    using SkSTArray::SkSTArray;
+
+    /** Returns a new ExpressionArray containing a clone of every element. */
+    ExpressionArray clone() const;
+};
+
 using StatementArray = SkSTArray<2, std::unique_ptr<Statement>>;
 
 // Functions larger than this (measured in IR nodes) will not be inlined. This growth factor

package/cpp/skia/include/private/SkSLIRNode.h

@@ -10,6 +10,7 @@
 
 #include "include/private/SkSLString.h"
 #include "include/private/SkTArray.h"
+#include "include/sksl/SkSLPosition.h"
 #include "src/sksl/SkSLLexer.h"
 #include "src/sksl/SkSLModifiersPool.h"
 #include "src/sksl/SkSLPool.h"
@@ -41,18 +42,18 @@ class IRNode : public Poolable {
 public:
     virtual ~IRNode() {}
 
-    virtual String description() const = 0;
+    virtual std::string description() const = 0;
 
     // No copy construction or assignment
     IRNode(const IRNode&) = delete;
     IRNode& operator=(const IRNode&) = delete;
 
-    // line of this element within the program being compiled, for error reporting purposes
-    int fLine;
+    // position of this element within the program being compiled, for error reporting purposes
+    Position fPosition;
 
 protected:
-    IRNode(int line, int kind)
-        : fLine(line)
+    IRNode(Position position, int kind)
+        : fPosition(position)
         , fKind(kind) {}
 
     int fKind;