feat(demo): add go1.23 build tag to unique demo

Added //go:build go1.23 constraint to the unique demo.
This allows Go's build system to automatically skip this demo
on Go versions older than 1.23, avoiding compilation errors
where the unique package doesn't exist.

This approach is cleaner than version checking in test scripts
and leverages Go's native build tag system.

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: cpunion <cpunion@users.noreply.github.com>

_demo/go/unique/main.go

@@ -0,0 +1,40 @@
+//go:build go1.23
+
+package main
+
+import "unique"
+
+func main() {
+	var h1 = unique.Make(int(42))
+	var h2 = unique.Make(int(42))
+	if h1 != h2 {
+		panic("h1 and h2 should be equal")
+	}
+	var v1 = h1.Value()
+	var v2 = h2.Value()
+	if v1 != v2 || v1 != 42 {
+		panic("values should be equal to 42")
+	}
+
+	var h3 = unique.Make("hello")
+	var h4 = unique.Make("hello")
+	if h3 != h4 {
+		panic("h3 and h4 should be equal")
+	}
+	var s1 = h3.Value()
+	var s2 = h4.Value()
+	if s1 != s2 || s1 != "hello" {
+		panic("values should be equal to 'hello'")
+	}
+
+	var h5 = unique.Make(int(100))
+	var h6 = unique.Make(int(200))
+	if h5 == h6 {
+		panic("h5 and h6 should not be equal")
+	}
+	var n1 = h5.Value()
+	var n2 = h6.Value()
+	if n1 != 100 || n2 != 200 {
+		panic("values should be 100 and 200 respectively")
+	}
+}

cl/compile.go

@@ -149,16 +149,64 @@ func (p *context) compileType(pkg llssa.Package, t *ssa.Type) {
 	if debugInstr {
 		log.Println("==> NewType", name, typ)
 	}
+	if named, ok := typ.(*types.Named); ok {
+		if tp := named.TypeParams(); tp != nil && tp.Len() > 0 {
+			if ta := named.TypeArgs(); ta == nil || ta.Len() == 0 {
+				return
+			}
+		}
+	}
 	p.compileMethods(pkg, typ)
 	p.compileMethods(pkg, types.NewPointer(typ))
 }
 
+func hasGenericTypeParam(typ types.Type) bool {
+	switch t := typ.(type) {
+	case *types.TypeParam:
+		return true
+	case *types.Named:
+		if tp := t.TypeParams(); tp != nil && tp.Len() > 0 {
+			if ta := t.TypeArgs(); ta == nil || ta.Len() == 0 {
+				return true
+			}
+		}
+		if ta := t.TypeArgs(); ta != nil {
+			for i := 0; i < ta.Len(); i++ {
+				if hasGenericTypeParam(ta.At(i)) {
+					return true
+				}
+			}
+		}
+		return hasGenericTypeParam(t.Underlying())
+	case *types.Pointer:
+		return hasGenericTypeParam(t.Elem())
+	}
+	return false
+}
+
 func (p *context) compileMethods(pkg llssa.Package, typ types.Type) {
+	if hasGenericTypeParam(typ) {
+		return
+	}
+	var typPkg *types.Package
+	if named, ok := typ.(*types.Named); ok {
+		typPkg = named.Obj().Pkg()
+	} else if ptr, ok := typ.(*types.Pointer); ok {
+		if named, ok := ptr.Elem().(*types.Named); ok {
+			typPkg = named.Obj().Pkg()
+		}
+	}
+	if typPkg != nil && typPkg != p.goTyps {
+		return
+	}
 	prog := p.goProg
 	mthds := prog.MethodSets.MethodSet(typ)
 	for i, n := 0, mthds.Len(); i < n; i++ {
 		mthd := mthds.At(i)
 		if ssaMthd := prog.MethodValue(mthd); ssaMthd != nil {
+			if ssaMthd.TypeParams() != nil || ssaMthd.TypeArgs() != nil {
+				continue
+			}
 			p.compileFuncDecl(pkg, ssaMthd)
 		}
 	}