Disallow unsized array dimensions on size fields past the frontmost.

This was slightly complicated by the fact that this syntax indicates an
array with a known size:

    float[] x = float[](1, 2, 3, 4);

Of course, the size is 4; it's just never explicitly stated in the
code. (The SkSL parser never actually deduces the size, but it doesn't
apparently have a need to; we don't do much in the way of optimization
for arrays.) However, this prevents us from simply failing whenever we
parse "[]" in non-builtin code; we need to keep scanning and see if the
variable is initialized. We already check this in the
ArrayConstructors.sksl test file.

Change-Id: I5b86958e81bd9bf5edf28a617cecf95c1875583e
Bug: skia:10957
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/335240
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: John Stiles <johnstiles@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>

Author: johnstiles-google

gn/sksl_tests.gni

@@ -73,6 +73,7 @@ sksl_error_tests = [
   "$_tests/sksl/errors/ArgumentMismatch.sksl",
   "$_tests/sksl/errors/ArgumentModifiers.sksl",
   "$_tests/sksl/errors/ArrayTooManyDimensions.sksl",
+  "$_tests/sksl/errors/ArrayUnspecifiedDimensions.sksl",
   "$_tests/sksl/errors/AssignmentTypeMismatch.sksl",
   "$_tests/sksl/errors/BadCaps.sksl",
   "$_tests/sksl/errors/BadFieldAccess.sksl",

src/sksl/SkSLIRGenerator.cpp

@@ -395,24 +395,26 @@ StatementArray IRGenerator::convertVarDeclarations(const ASTNode& decls,
                 }
                 String name(type->name());
                 int64_t count;
-                if (size->is<IntLiteral>()) {
-                    count = size->as<IntLiteral>().value();
-                    if (count <= 0) {
-                        fErrors.error(size->fOffset, "array size must be positive");
-                        return {};
-                    }
-                    name += "[" + to_string(count) + "]";
-                } else {
-                    fErrors.error(size->fOffset, "array size must be specified");
+                if (!size->is<IntLiteral>()) {
+                    fErrors.error(size->fOffset, "array size must be an integer");
+                    return {};
+                }
+                count = size->as<IntLiteral>().value();
+                if (count <= 0) {
+                    fErrors.error(size->fOffset, "array size must be positive");
                     return {};
                 }
+                name += "[" + to_string(count) + "]";
                 type = fSymbolTable->takeOwnershipOfSymbol(
                         std::make_unique<Type>(name, Type::TypeKind::kArray, *type, (int)count));
                 sizes.push_back(std::move(size));
-            } else {
+            } else if (i == 0) {
                 type = fSymbolTable->takeOwnershipOfSymbol(std::make_unique<Type>(
                         type->name() + "[]", Type::TypeKind::kArray, *type, Type::kUnsizedArray));
                 sizes.push_back(nullptr);
+            } else {
+                fErrors.error(varDecl.fOffset, "array size must be specified");
+                return {};
             }
         }
         auto var = std::make_unique<Variable>(varDecl.fOffset, fModifiers->addToPool(modifiers),
@@ -423,7 +425,13 @@ StatementArray IRGenerator::convertVarDeclarations(const ASTNode& decls,
             fRTAdjust = var.get();
         }
         std::unique_ptr<Expression> value;
-        if (iter != varDecl.end()) {
+        if (iter == varDecl.end()) {
+            if (varData.fSizeCount > 0 && sizes.front() == nullptr) {
+                fErrors.error(varDecl.fOffset,
+                              "arrays without an explicit size must use an initializer expression");
+                return {};
+            }
+        } else {
             value = this->convertExpression(*iter);
             if (!value) {
                 return {};
@@ -1258,7 +1266,7 @@ void IRGenerator::convertEnum(const ASTNode& e) {
                 return;
             }
         }
-        value = std::unique_ptr<Expression>(new IntLiteral(fContext, e.fOffset, currentValue));
+        value = std::make_unique<IntLiteral>(fContext, e.fOffset, currentValue);
         ++currentValue;
         fSymbolTable->add(std::make_unique<Variable>(e.fOffset, fModifiers->addToPool(modifiers),
                                                      child.getString(), type, fIsBuiltinCode,

tests/sksl/errors/ArrayUnspecifiedDimensions.sksl

@@ -0,0 +1,14 @@
+in int arr1[][2][3][4][5][6][7][8];
+in int arr2[1][][3][4][5][6][7][8];
+in int arr3[1][2][][4][5][6][7][8];
+in int arr4[1][2][3][][5][6][7][8];
+in int arr5[1][2][3][4][][6][7][8];
+in int arr6[1][2][3][4][5][][7][8];
+in int arr7[1][2][3][4][5][6][][8];
+in int arr8[1][2][3][4][5][6][7][];
+in int arrEven[1][][3][][5][][7][];
+in int arrOdd[][2][][4][][6][][8];
+in int arrNone[][][][][][][][];
+in int arrFloat[1.];
+in int arrBool[true];
+in int arrNull[null];

tests/sksl/errors/FieldAfterRuntimeArray.sksl

@@ -1 +1,2 @@
-buffer broken { float x[]; float y; };
+buffer brokenA { float x[];              float y; };
+buffer brokenB { float x[] = float[](0); float y; };

tests/sksl/errors/golden/ArrayUnspecifiedDimensions.glsl

@@ -0,0 +1,17 @@
+### Compilation failed:
+
+error: 1: arrays without an explicit size must use an initializer expression
+error: 2: array size must be specified
+error: 3: array size must be specified
+error: 4: array size must be specified
+error: 5: array size must be specified
+error: 6: array size must be specified
+error: 7: array size must be specified
+error: 8: array size must be specified
+error: 9: array size must be specified
+error: 10: array size must be specified
+error: 11: array size must be specified
+error: 12: expected 'int', but found 'float'
+error: 13: expected 'int', but found 'bool'
+error: 14: arrays without an explicit size must use an initializer expression
+14 errors

tests/sksl/errors/golden/FieldAfterRuntimeArray.glsl

@@ -1,4 +1,6 @@
 ### Compilation failed:
 
-error: 1: only the last entry in an interface block may be a runtime-sized array
-1 error
+error: 1: arrays without an explicit size must use an initializer expression
+error: 2: initializers are not permitted on interface block fields
+error: 2: only the last entry in an interface block may be a runtime-sized array
+3 errors