I was able to get this to compile by using Clang (go env -w CC="clang"), but it'd be nice for it to work out-of-the-box as well. Another thing to add is that I built the quickjs library with GCC, and it handled the header correctly, so this seems like an issue with Cgo's configuration than with GCC itself, but I could be wrong.

@golang/compiler

This doesn't have anything to do with cgo or Go. A pure C file

#include "ctest.h"
JSValue x = JS_UNDEFINED;

will report the same error when using GCC.

@ianlancetaylor The error you get when compiling your code is slightly different:

ctest.h:19:37: error: initializer element is not constant
   19 | #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
      |                                     ^
ctest.h:20:22: note: in expansion of macro ‘JS_MKVAL’
   20 | #define JS_UNDEFINED JS_MKVAL(JS_TAG_UNDEFINED, 0)
      |                      ^~~~~~~~
ctest.c:3:13: note: in expansion of macro ‘JS_UNDEFINED’
    3 | JSValue x = JS_UNDEFINED;

You'll notice your const assignment is actually part of the error. No where in my Cgo example do I create a const assignment, so it's unclear where the error is coming from.

For instance, if you write a C function similar to my Go function, GCC will compile it:

#include "ctest.h"

int main() {
  JSValue x = JS_UNDEFINED;
}

The error string is coming from the cgo tool. It's because the cgo tool itself needs to determine the type of the value. It does by writing out

__typeof__(JS_UNDEFINED) *__cgo__1;

It compiles that as C code, and looks at the DWARF debug info to determine type. Unfortunately, that code doesn't compile when using GCC.

I think that to make this work with GCC you are going to write something like

/*
#include "ctest.h"

static JSValue undef() { return JS_UNDEFINED; }
*/
import "C"
import "fmt"

func MyTest() {
	var s C.JSValue = C.undef()
	fmt.Println(s)
}