问当返回带有uint数组成员的结构时，OpenGL错误1282

EN

#version 460

uniform uint param;
out vec4 color;

struct A {
    uint content[2];
};

A createA1(const uint data) { return A( uint[2](data, data) ); }
A createA2(const uint data) { return A( uint[2](data, 0   ) ); }
A createA3(const uint data) { return A( uint[2](data, 0u  ) ); }
A createA4(const uint data) { return A( uint[2](0   , 0   ) ); }

void main() {
    const uint o = param;

    const A a0 = A( uint[2](o, 0) );
    const A a1 = createA1(o);
    //const A a2 = createA2(o);
    const A a3 = createA3(o);
    const A a4 = createA4(o);
    
    color = vec4(1);
}

Fragment info
-------------
0(11) : error C7011: implicit cast from "int" to "uint"

#include <GLEW/glew.h>
#include <GLFW/glfw3.h>

#include<iostream>

void check_(int line) {
    GLenum error;
    while ((error = glGetError()) != GL_NO_ERROR) { 
        std::cout << "Error on line " << line << ": " << error << std::endl;
    }
}
#define check() check_(__LINE__)
                            
int main() {
    if (!glfwInit()) return -1;
    GLFWwindow *window = glfwCreateWindow(50, 50, "", NULL, NULL);
    if (!window) return (glfwTerminate(), -1);
    glfwMakeContextCurrent(window);
    GLenum err = glewInit();
    if (err != GLEW_OK) {
        std::cout << "GLEW error: %s\n" << glewGetErrorString(err) << '\n';     
        glfwTerminate();
        return -1;
    }
    
    GLuint prog = glCreateProgram();
    
    GLuint shader_vert = glCreateShader(GL_VERTEX_SHADER);
    GLuint shader_frag = glCreateShader(GL_FRAGMENT_SHADER);
    
    char const *source_vert = R"(#version 460
        void main() {
            const vec2 verts[] = {vec2(-1),vec2(1, -1),vec2(-1, 1),vec2(1)};
            gl_Position = vec4( verts[gl_VertexID], 0, 1 );
        }
    )";
    char const *source_frag = R"(#version 460
        
        uniform uint param;
        out vec4 color;
        
        struct A {
            uint content[2];
        };
        
        A createA1(const uint data) { return A( uint[2](data, data) ); }
        A createA2(const uint data) { return A( uint[2](data, 0   ) ); }
        A createA3(const uint data) { return A( uint[2](data, 0u  ) ); }
        A createA4(const uint data) { return A( uint[2](0   , 0   ) ); }
        
        void main() {
            const uint o = param;
            
            const A a0 = A( uint[2](o, 0) );
            const A a1 = createA1(o);
            const A a2 = createA2(o);
            const A a3 = createA3(o);
            const A a4 = createA4(o);
            
            color = vec4(1);
        }
    )";
    
    glShaderSource(shader_vert, 1, &source_vert, nullptr); 
    glCompileShader(shader_vert);
    glShaderSource(shader_frag, 1, &source_frag, nullptr); 
    glCompileShader(shader_frag);
    
    GLint result_vert;
    glGetShaderiv(shader_vert, GL_COMPILE_STATUS, &result_vert);
    std::cout << "result_vert: " << result_vert << '\n';
    GLint result_frag;
    glGetShaderiv(shader_frag, GL_COMPILE_STATUS, &result_frag);
    std::cout << "result_frag: " << result_frag << '\n';
    //check(); //additional checks were ommited after the problem was found
    
    glAttachShader(prog, shader_vert);
    glAttachShader(prog, shader_frag);
    
    glLinkProgram(prog);
    GLint progStatus;
    glGetProgramiv(prog, GL_LINK_STATUS, &progStatus);
    std::cout << "Program status: " << progStatus << '\n';
    {
        int length;
        glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &length);
        GLchar *msg = new GLchar[length + 1];
        msg[0] = '\0';
        glGetProgramInfoLog(prog, length, &length, msg);
        std::cout << "Program error:\n" << msg;
        delete[] msg;
    }
    
    glValidateProgram(prog);
    GLint progValidate;
    glGetProgramiv(prog, GL_VALIDATE_STATUS, &progValidate);
    std::cout << "Program valid: " << progValidate << '\n';
    //check();
    
    glUseProgram(prog);
    check();
    
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    
    return 0;
}