code review 5336041: cgo: print error instead of panic on undeclared enums/s...

src/cmd/cgo/gcc.go

 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Annotate Ref in Prog with C types by parsing gcc debug output.
 // Conversion of debug output to Go types.
 
 package main
 
 import (
@@ skipping 559 matching lines @@
                 }
                 if e.Tag != dwarf.TagCompileUnit {
                         r.SkipChildren()
                 }
         }
 
         // Record types and typedef information.
         var conv typeConv
         conv.Init(p.PtrSize)
         for i, n := range names {
+                if types[i] == nil {
+                        continue
+                }
                 f, fok := types[i].(*dwarf.FuncType)
                 if n.Kind != "type" && fok {
                         n.Kind = "func"
                         n.FuncType = conv.FuncType(f)
                 } else {
                         n.Type = conv.Type(types[i])
                         if enums[i] != 0 && n.Type.EnumValues != nil {
                                 k := fmt.Sprintf("__cgo_enum__%d", i)
                                 n.Kind = "const"
                                 n.Const = strconv.Itoa64(n.Type.EnumValues[k])
@@ skipping 67 matching lines @@
                                 // Okay - might be new(T)
                                 expr = r.Name.Type.Go
                         }
                         if r.Name.Kind == "var" {
                                 expr = &ast.StarExpr{X: expr}
                         }
 
                 case "type":
                         if r.Name.Kind != "type" {
                                 error_(r.Pos(), "expression C.%s used as type", r.Name.Go)
+                        } else if r.Name.Type == nil {
+                                // Use of C.enum_x, C.struct_x or C.union_x without C definition.
+                                // GCC won't raise an error when using pointers to such unknown types.
+                                error_(r.Pos(), "type C.%s: undefined C type '%s'", r.Name.Go, r.Name.C)
                         } else {
                                 expr = r.Name.Type.Go
                         }
                 default:
                         if r.Name.Kind == "func" {
                                 error_(r.Pos(), "must call C.%s", r.Name.Go)
                         }
                 }
                 *r.Expr = expr
         }
@@ skipping 689 matching lines @@
                 off = dt.ByteSize
         }
         if off != dt.ByteSize {
                 fatalf("struct size calculation error")
         }
         buf.WriteString("}")
         csyntax = buf.String()
         expr = &ast.StructType{Fields: &ast.FieldList{List: fld}}
         return
 }