HLSL: allow implicit array sizing.

Test/hlsl.array.implicit-size.frag

+
+// implicit sized array
+uniform float g_array [ ] = { 1, 2, 3, 4, 5 };
+
+// Unused implicit sized array
+uniform float g_array_unused [ ] = { 1, 2, 3, 4, 5, 6, 7 };
+
+// Test implicit size arrayed structs
+uniform struct mystruct {
+    int i;
+    float f;
+} g_mystruct[] = {
+    { 1, 2.0 },
+    { 3, 4.0 },
+};
+
+struct PS_OUTPUT { float4 color : SV_Target0; };
+
+// INVALID: implicit size requires an initializer expression.
+// uniform float bad[];
+
+// INVALID: function parameters cannot be implicitly sized
+// void BadFunction(int a[]) { }
+
+void main(out PS_OUTPUT ps_output)
+{
+    // implicit sized local array
+    float l_array[] = { 1, 2, 3 };
+
+    ps_output.color = g_array[0] + g_array[4] + l_array[1] + g_mystruct[0].f + g_array[idx];
+}

gtests/Hlsl.FromFile.cpp

@@ -81,6 +81,7 @@ INSTANTIATE_TEST_CASE_P(
     ToSpirv, HlslCompileTest,
     ::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
         {"hlsl.array.frag", "PixelShaderFunction"},
+        {"hlsl.array.implicit-size.frag", "PixelShaderFunction"},
         {"hlsl.assoc.frag", "PixelShaderFunction"},
         {"hlsl.attribute.frag", "PixelShaderFunction"},
         {"hlsl.buffer.frag", "PixelShaderFunction"},

hlsl/hlslGrammar.cpp

@@ -1515,8 +1515,14 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function)
     // array_specifier
     TArraySizes* arraySizes = nullptr;
     acceptArraySpecifier(arraySizes);
-    if (arraySizes)
+    if (arraySizes) {
+        if (arraySizes->isImplicit()) {
+            parseContext.error(token.loc, "function parameter array cannot be implicitly sized", "", "");
+            return false;
+        }
+
         type->newArraySizes(*arraySizes);
+    }
 
     // post_decls
     acceptPostDecls(type->getQualifier());
@@ -2601,6 +2607,7 @@ bool HlslGrammar::acceptDefaultLabel(TIntermNode*& statement)
 
 // array_specifier
 //      : LEFT_BRACKET integer_expression RGHT_BRACKET post_decls // optional
+//      : LEFT_BRACKET RGHT_BRACKET post_decls // optional
 //
 void HlslGrammar::acceptArraySpecifier(TArraySizes*& arraySizes)
 {
@@ -2610,21 +2617,25 @@ void HlslGrammar::acceptArraySpecifier(TArraySizes*& arraySizes)
         return;
 
     TSourceLoc loc = token.loc;
-    TIntermTyped* sizeExpr;
-    if (! acceptAssignmentExpression(sizeExpr)) {
-        expected("array-sizing expression");
-        return;
-    }
+    TIntermTyped* sizeExpr = nullptr;
+
+    // Array sizing expression is optional.  If ommitted, array is implicitly sized.
+    const bool hasArraySize = acceptAssignmentExpression(sizeExpr);
 
     if (! acceptTokenClass(EHTokRightBracket)) {
         expected("]");
         return;
     }
 
-    TArraySize arraySize;
-    parseContext.arraySizeCheck(loc, sizeExpr, arraySize);
     arraySizes = new TArraySizes;
-    arraySizes->addInnerSize(arraySize);
+    
+    if (hasArraySize) {
+        TArraySize arraySize;
+        parseContext.arraySizeCheck(loc, sizeExpr, arraySize);
+        arraySizes->addInnerSize(arraySize);
+    } else {
+        arraySizes->addInnerSize();  // implicitly sized
+    }
 }
 
 // post_decls