More test cases for ParseFieldPath

Author: sublee

internal/convgen/parse/struct.go

@@ -29,17 +29,21 @@ func (ps structParsers) parse(p *Parser, expr ast.Expr, owner typeinfo.Type) (*P
 	}
 
 	if len(path.StructField) == 0 {
-		panic(1)
+		panic("unreachable: struct field must be at least one")
 	}
 	if len(path.StructField) == 1 {
 		return nil, codefmt.Errorf(p, expr, "cannot use %t itself as a field", owner)
 	}
 	return path, nil
 }
 
-func (ps structParsers) walk(p *Parser, expr ast.Expr, owner typeinfo.Type) (*Path, error) {
+func (ps structParsers) walk(p *Parser, expr ast.Expr, owner typeinfo.Type) (*Path, error) { // nolint:gocyclo
 	expr = ast.Unparen(expr)
 
+	if !owner.Deref().IsNamed() {
+		return nil, codefmt.Errorf(p, expr, "field of anonymous struct is not supported")
+	}
+
 	// Unwrap convgen.Field~ function calls
 	// e.g., convgen.FieldGetter(T{}.GetField) -> T{}.GetField
 	if call, ok := expr.(*ast.CallExpr); ok {
@@ -51,51 +55,55 @@ func (ps structParsers) walk(p *Parser, expr ast.Expr, owner typeinfo.Type) (*Pa
 
 	switch x := expr.(type) {
 	case *ast.CompositeLit:
+		err := codefmt.Errorf(p, expr, "field should belong to %t{}; got %c", owner, expr)
+
 		// Expression: T{}
 		if len(x.Elts) != 0 {
 			// T{...}
-			return nil, codefmt.Errorf(p, expr, "field should belong to %t{} with empty braces; got %c", owner, expr)
+			return nil, err
 		}
 
 		id, ok := ast.Unparen(x.Type).(*ast.Ident)
 		if !ok {
 			// struct{}{}
-			return nil, codefmt.Errorf(p, expr, "field cannot belong to anonymous struct")
+			return nil, err
 		}
 
 		t := typeinfo.TypeOf(p.Pkg().TypesInfo.TypeOf(id))
 		if !t.Identical(owner.Deref()) {
 			// U{} where U != T
-			return nil, codefmt.Errorf(p, expr, "field should belong to %t{}; got %c", owner, expr)
+			return nil, err
 		}
 
 		obj := p.Pkg().TypesInfo.ObjectOf(id)
 		return &Path{StructField: []types.Object{obj}, Pos: id.Pos()}, nil
 
 	case *ast.CallExpr:
+		err := codefmt.Errorf(p, expr, "field should belong to (*%t)(nil); got %c", owner, expr)
+
 		// Expression: (*T)(nil)
 		if len(x.Args) != 1 || !p.IsNil(x.Args[0]) {
 			// (nil) expected but got (), (nonil), (...)
-			return nil, codefmt.Errorf(p, expr, "field should belong to (*%t)(nil); got %c", owner, expr)
+			return nil, err
 		}
 
 		fun := ast.Unparen(x.Fun)
 		star, ok := fun.(*ast.StarExpr)
 		if !ok {
 			// f(nil) where f != *T
-			return nil, codefmt.Errorf(p, expr, "field should belong to (*%t)(nil); got %c", owner, expr)
+			return nil, err
 		}
 
 		id, ok := ast.Unparen(star.X).(*ast.Ident)
 		if !ok {
 			// (*struct{})(nil)
-			return nil, codefmt.Errorf(p, expr, "field cannot belong to anonymous struct")
+			return nil, err
 		}
 
 		t := typeinfo.TypeOf(p.Pkg().TypesInfo.TypeOf(id))
 		if !t.Identical(owner.Deref()) {
 			// (*U)(nil) where U != T
-			return nil, codefmt.Errorf(p, expr, "field should belong to (*%t)(nil); got %c", owner, expr)
+			return nil, err
 		}
 
 		obj := p.Pkg().TypesInfo.ObjectOf(id)

testdata/analysis/ParseFieldPath/testdata.go

@@ -14,24 +14,30 @@ func f(...any) X { return X{} }
 var Case1 = convgen.Struct[X, X](nil,
 	convgen.Match(X{}.A, X{}.A.B),             // ok
 	convgen.Match(X{}.A, X{}),                 // want `cannot use X itself as a field`
-	convgen.Match(X{}.A, X{Y{1}}.A.B),         // want `field should belong to X\{\} with empty braces; got X\{Y\{1\}\}`
+	convgen.Match(X{}.A, X{Y{1}}.A.B),         // want `field should belong to X\{\}; got X\{Y\{1\}\}`
 	convgen.Match(X{}.A, Y{}.B),               // want `field should belong to X\{\}; got Y\{\}`
-	convgen.Match(X{}.A, struct{ A Y }{}.A.B), // want `field cannot belong to anonymous struct`
+	convgen.Match(X{}.A, struct{ A Y }{}.A.B), // want `field should belong to X\{\}; got struct\{ A Y \}\{\}`
 
 	convgen.Match(X{}.A, (*X)(nil).A.B),             // ok
 	convgen.Match(X{}.A, f().A.B),                   // want `field should belong to \(\*X\)\(nil\); got f\(\)`
 	convgen.Match(X{}.A, f(nil).A.B),                // want `field should belong to \(\*X\)\(nil\); got f\(nil\)`
 	convgen.Match(X{}.A, f(1).A.B),                  // want `field should belong to \(\*X\)\(nil\); got f\(1\)`
 	convgen.Match(X{}.A, (*Y)(nil).B),               // want `field should belong to \(\*X\)\(nil\); got \(\*Y\)\(nil\)`
-	convgen.Match(X{}.A, (*struct{ A Y })(nil).A.B), // want `field cannot belong to anonymous struct`
+	convgen.Match(X{}.A, (*struct{ A Y })(nil).A.B), // want `field should belong to \(\*X\)\(nil\); got \(\*struct\{ A Y \}\)\(nil\)`
 
 	convgen.Match(X{}.A, (&X{}).A.B),    // ok
 	convgen.Match(X{}.A, &(&X{}).A.B),   // ok
 	convgen.Match(X{}.A, (*(&X{})).A.B), // ok
+
+	convgen.Match(X{}.A, 0),           // want `invalid field expression; got 0`
+	convgen.Match(X{}.A, []X{}),       // want `field should belong to X\{\}; got \[\]X\{\}`
+	convgen.Match(X{}.A, map[int]X{}), // want `field should belong to X\{\}; got map\[int\]X\{\}`
 )
 
 var Case2 = convgen.Struct[X, struct{ X }](nil,
-	convgen.Match(X{}.A, struct{ X }{}.X.A.B), // want `field cannot belong to anonymous struct`
+	convgen.Match(X{}.A, struct{ X }{}.X.A.B), // want `field of anonymous struct is not supported`
+	convgen.Match(X{}.A, struct{ X }{}.X),     // want `field of anonymous struct is not supported`
+	convgen.Match(X{}.A, 0),                   // want `field of anonymous struct is not supported`
 )
 
 type Z struct {