Only include one variable per declaration statement

This removes VarDeclarationsStatement entirely. VarDeclaration instances
appear directly as statements in Programs. SkSL that declares multiple
variables in a single declaration is transformed to represent that as a
series of VarDeclaration statements.

Similarly, global variable declarations are represented by
GlobalVarDeclaration program elements, one per variable.

Bug: skia:10806
Change-Id: Idd8a2d971a8217733ed57f0dd2249d62f2f0e9c5
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/323102
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: John Stiles <johnstiles@google.com>

Author: brianosman

gn/sksl.gni

@@ -106,7 +106,6 @@ skia_sksl_sources = [
   "$_src/sksl/ir/SkSLTypeReference.h",
   "$_src/sksl/ir/SkSLUnresolvedFunction.h",
   "$_src/sksl/ir/SkSLVarDeclarations.h",
-  "$_src/sksl/ir/SkSLVarDeclarationsStatement.h",
   "$_src/sksl/ir/SkSLVariable.h",
   "$_src/sksl/ir/SkSLVariableReference.cpp",
   "$_src/sksl/ir/SkSLVariableReference.h",

src/core/SkRuntimeEffect.cpp

@@ -153,68 +153,66 @@ SkRuntimeEffect::EffectResult SkRuntimeEffect::Make(SkString sksl) {
     // Go through program elements, pulling out information that we need
     for (const auto& elem : *program) {
         // Variables (uniform, varying, etc.)
-        if (elem.kind() == SkSL::ProgramElement::Kind::kVar) {
-            const auto& varDecls = static_cast<const SkSL::VarDeclarations&>(elem);
-            for (const auto& varDecl : varDecls.fVars) {
-                const SkSL::Variable& var =
-                        *(static_cast<const SkSL::VarDeclaration&>(*varDecl).fVar);
-                const SkSL::Type& varType = var.type();
-
-                // Varyings (only used in conjunction with drawVertices)
-                if (var.fModifiers.fFlags & SkSL::Modifiers::kVarying_Flag) {
-                    varyings.push_back({var.name(),
-                                        varType.typeKind() == SkSL::Type::TypeKind::kVector
-                                               ? varType.columns()
-                                               : 1});
-                }
-                // Fragment Processors (aka 'shader'): These are child effects
-                else if (&varType == ctx.fFragmentProcessor_Type.get()) {
-                    children.push_back(var.name());
-                    sampleUsages.push_back(SkSL::Analysis::GetSampleUsage(*program, var));
+        if (elem.is<SkSL::GlobalVarDeclaration>()) {
+            const auto& varDecl = elem.as<SkSL::GlobalVarDeclaration>().fDecl;
+
+            const SkSL::Variable& var = *varDecl->fVar;
+            const SkSL::Type& varType = var.type();
+
+            // Varyings (only used in conjunction with drawVertices)
+            if (var.fModifiers.fFlags & SkSL::Modifiers::kVarying_Flag) {
+                varyings.push_back({var.name(),
+                                    varType.typeKind() == SkSL::Type::TypeKind::kVector
+                                            ? varType.columns()
+                                            : 1});
+            }
+            // Fragment Processors (aka 'shader'): These are child effects
+            else if (&varType == ctx.fFragmentProcessor_Type.get()) {
+                children.push_back(var.name());
+                sampleUsages.push_back(SkSL::Analysis::GetSampleUsage(*program, var));
+            }
+            // 'uniform' variables
+            else if (var.fModifiers.fFlags & SkSL::Modifiers::kUniform_Flag) {
+                Uniform uni;
+                uni.fName = var.name();
+                uni.fFlags = 0;
+                uni.fCount = 1;
+
+                const SkSL::Type* type = &var.type();
+                if (type->typeKind() == SkSL::Type::TypeKind::kArray) {
+                    uni.fFlags |= Uniform::kArray_Flag;
+                    uni.fCount = type->columns();
+                    type = &type->componentType();
                 }
-                // 'uniform' variables
-                else if (var.fModifiers.fFlags & SkSL::Modifiers::kUniform_Flag) {
-                    Uniform uni;
-                    uni.fName = var.name();
-                    uni.fFlags = 0;
-                    uni.fCount = 1;
-
-                    const SkSL::Type* type = &var.type();
-                    if (type->typeKind() == SkSL::Type::TypeKind::kArray) {
-                        uni.fFlags |= Uniform::kArray_Flag;
-                        uni.fCount = type->columns();
-                        type = &type->componentType();
-                    }
 
-                    if (!init_uniform_type(ctx, type, &uni)) {
-                        RETURN_FAILURE("Invalid uniform type: '%s'", type->displayName().c_str());
-                    }
+                if (!init_uniform_type(ctx, type, &uni)) {
+                    RETURN_FAILURE("Invalid uniform type: '%s'", type->displayName().c_str());
+                }
 
-                    const SkSL::StringFragment& marker(var.fModifiers.fLayout.fMarker);
-                    if (marker.fLength) {
-                        uni.fFlags |= Uniform::kMarker_Flag;
-                        allowColorFilter = false;
-                        if (!parse_marker(marker, &uni.fMarker, &uni.fFlags)) {
-                            RETURN_FAILURE("Invalid 'marker' string: '%.*s'", (int)marker.fLength,
-                                            marker.fChars);
-                        }
+                const SkSL::StringFragment& marker(var.fModifiers.fLayout.fMarker);
+                if (marker.fLength) {
+                    uni.fFlags |= Uniform::kMarker_Flag;
+                    allowColorFilter = false;
+                    if (!parse_marker(marker, &uni.fMarker, &uni.fFlags)) {
+                        RETURN_FAILURE("Invalid 'marker' string: '%.*s'", (int)marker.fLength,
+                                        marker.fChars);
                     }
+                }
 
-                    if (var.fModifiers.fLayout.fFlags & SkSL::Layout::Flag::kSRGBUnpremul_Flag) {
-                        uni.fFlags |= Uniform::kSRGBUnpremul_Flag;
-                    }
+                if (var.fModifiers.fLayout.fFlags & SkSL::Layout::Flag::kSRGBUnpremul_Flag) {
+                    uni.fFlags |= Uniform::kSRGBUnpremul_Flag;
+                }
 
-                    uni.fOffset = offset;
-                    offset += uni.sizeInBytes();
-                    SkASSERT(SkIsAlign4(offset));
+                uni.fOffset = offset;
+                offset += uni.sizeInBytes();
+                SkASSERT(SkIsAlign4(offset));
 
-                    uniforms.push_back(uni);
-                }
+                uniforms.push_back(uni);
             }
         }
         // Functions
-        else if (elem.kind() == SkSL::ProgramElement::Kind::kFunction) {
-            const auto& func = static_cast<const SkSL::FunctionDefinition&>(elem);
+        else if (elem.is<SkSL::FunctionDefinition>()) {
+            const auto& func = elem.as<SkSL::FunctionDefinition>();
             const SkSL::FunctionDeclaration& decl = func.fDeclaration;
             if (decl.name() == "main") {
                 hasMain = true;

src/gpu/effects/generated/GrAARectEffect.cpp

@@ -40,7 +40,9 @@ half alpha;
         alpha = half(all(greaterThan(float4(sk_FragCoord.xy, %s.zw), float4(%s.xy, sk_FragCoord.xy))) ? 1 : 0);
         break;
     default:
-        half xSub, ySub;
+        half xSub;
+        half ySub;
+
         xSub = min(half(sk_FragCoord.x - %s.x), 0.0);
         xSub += min(half(%s.z - sk_FragCoord.x), 0.0);
         ySub = min(half(sk_FragCoord.y - %s.y), 0.0);

src/gpu/effects/generated/GrHighContrastFilterEffect.cpp

@@ -48,6 +48,8 @@ if (t > 1.0) t -= 1.0;
 return t < 0.1666666716337204 ? p + ((q - p) * 6.0) * t : (t < 0.5 ? q : (t < 0.66666668653488159 ? p + ((q - p) * (0.66666668653488159 - t)) * 6.0 : p));
 )SkSL",
                                   &HSLToRGB_name);
+        fragBuilder->codeAppendf(
+                R"SkSL(;)SkSL");
         SkString _sample896 = this->invokeChild(0, args);
         fragBuilder->codeAppendf(
                 R"SkSL(

src/gpu/effects/generated/GrLumaColorFilterEffect.cpp

@@ -27,7 +27,7 @@ class GrGLSLLumaColorFilterEffect : public GrGLSLFragmentProcessor {
         SkString _sample870 = this->invokeChild(0, args);
         fragBuilder->codeAppendf(
                 R"SkSL(half4 inputColor = %s;
-
+;
 half luma = clamp(dot(half3(0.2125999927520752, 0.71520000696182251, 0.072200000286102295), inputColor.xyz), 0.0, 1.0);
 %s = half4(0.0, 0.0, 0.0, luma);
 )SkSL",

src/gpu/effects/generated/GrRGBToHSLFilterEffect.cpp

@@ -29,7 +29,7 @@ class GrGLSLRGBToHSLFilterEffect : public GrGLSLFragmentProcessor {
                 R"SkSL(half4 c = %s;
 half4 p = c.y < c.z ? half4(c.zy, -1.0, 0.66666668653488159) : half4(c.yz, 0.0, -0.3333333432674408);
 half4 q = c.x < p.x ? half4(p.x, c.x, p.yw) : half4(c.x, p.x, p.yz);
-
+;
 half pmV = q.x;
 half pmC = pmV - min(q.y, q.z);
 half pmL = pmV - pmC * 0.5;

src/gpu/effects/generated/GrRectBlurEffect.cpp

@@ -49,7 +49,9 @@ class GrGLSLRectBlurEffect : public GrGLSLFragmentProcessor {
         }
         fragBuilder->codeAppendf(
                 R"SkSL(/* key */ bool highp = %s;
-half xCoverage, yCoverage;
+half xCoverage;
+half yCoverage;
+
 float2 pos = sk_FragCoord.xy;
 @if (%s) {
     pos = (%s * float3(pos, 1.0)).xy;

src/gpu/gradients/generated/GrDualIntervalGradientColorizer.cpp

@@ -47,7 +47,9 @@ class GrGLSLDualIntervalGradientColorizer : public GrGLSLFragmentProcessor {
                                                         kHalf_GrSLType, "threshold");
         fragBuilder->codeAppendf(
                 R"SkSL(half t = half(%s.x);
-float4 scale, bias;
+float4 scale;
+float4 bias;
+
 if (t < %s) {
     scale = %s;
     bias = %s;

src/gpu/gradients/generated/GrUnrolledBinaryGradientColorizer.cpp

@@ -129,7 +129,9 @@ class GrGLSLUnrolledBinaryGradientColorizer : public GrGLSLFragmentProcessor {
                                                              kHalf4_GrSLType, "thresholds9_13");
         fragBuilder->codeAppendf(
                 R"SkSL(half t = half(%s.x);
-float4 scale, bias;
+float4 scale;
+float4 bias;
+
 if (%d <= 4 || t < %s.w) {
     if (%d <= 2 || t < %s.y) {
         if (%d <= 1 || t < %s.x) {

src/sksl/SkSLAnalysis.cpp

@@ -35,7 +35,6 @@
 #include "src/sksl/ir/SkSLNop.h"
 #include "src/sksl/ir/SkSLReturnStatement.h"
 #include "src/sksl/ir/SkSLSwitchStatement.h"
-#include "src/sksl/ir/SkSLVarDeclarationsStatement.h"
 #include "src/sksl/ir/SkSLWhileStatement.h"
 
 // Expressions
@@ -486,10 +485,6 @@ bool TProgramVisitor<PROG, EXPR, STMT, ELEM>::visitStatement(STMT s) {
             }
             return v.fValue && this->visitExpression(*v.fValue);
         }
-        case Statement::Kind::kVarDeclarations:
-            return this->visitProgramElement(
-                    *s.template as<VarDeclarationsStatement>().fDeclaration);
-
         case Statement::Kind::kWhile: {
             auto& w = s.template as<WhileStatement>();
             return this->visitExpression(*w.fTest) || this->visitStatement(*w.fStatement);
@@ -520,11 +515,9 @@ bool TProgramVisitor<PROG, EXPR, STMT, ELEM>::visitProgramElement(ELEM pe) {
             }
             return false;
 
-        case ProgramElement::Kind::kVar:
-            for (auto& v : pe.template as<VarDeclarations>().fVars) {
-                if (this->visitStatement(*v)) {
-                    return true;
-                }
+        case ProgramElement::Kind::kGlobalVar:
+            if (this->visitStatement(*pe.template as<GlobalVarDeclaration>().fDecl)) {
+                return true;
             }
             return false;