Go Reflection System: Dynamic Type Inspection and Manipulation

Build a powerful reflection system in Go that allows for dynamic inspection of types, fields, and methods at runtime. This system will enable you to understand the structure of any given Go value, access and modify its fields, and even invoke its methods without prior knowledge of its concrete type. This is crucial for tasks like serialization/deserialization, ORMs, and generic utility functions.

Problem Description

Your task is to implement a Go package that provides reflection capabilities. This package should allow users to:

• Inspect Type Information: Determine the kind of a Go value (struct, int, string, slice, map, etc.), its name, and its underlying type.
• Access and Iterate Fields: For struct types, be able to list all fields, get their names, types, and values. You should also be able to get and set the value of a specific field by its name.
• Invoke Methods: For any value that has methods, be able to find a method by its name and invoke it with provided arguments, returning its results.
• Handle Pointers: Correctly dereference pointers to access the underlying value's type and fields.

Key Requirements:

• Inspect(v interface{}): A function that takes any Go value and returns an InspectionResult. The InspectionResult should contain information about the value's kind, name, and if it's a struct, its fields.
• GetField(instance interface{}, fieldName string): A function that takes an instance (which can be a pointer to a struct) and a field name, and returns the value of that field. It should also return an error if the field doesn't exist or if the instance is not a struct.
• SetField(instance interface{}, fieldName string, newValue interface{}): A function that takes an instance (which can be a pointer to a struct), a field name, and a new value, and sets the field's value. It should handle type compatibility and return an error if the operation fails.
• InvokeMethod(instance interface{}, methodName string, args ...interface{}) ([]interface{}, error): A function that takes an instance, a method name, and any number of arguments, and invokes the specified method on the instance. It should return a slice of results (in case of multiple return values) and an error.

Expected Behavior:

• The system should be robust and handle various Go types gracefully.
• Errors should be informative, indicating the reason for failure (e.g., field not found, type mismatch, not a struct).
• Pointer handling should be seamless, allowing direct access to fields or method invocation on pointer-to-structs as if they were structs themselves.

Edge Cases to Consider:

• Nil values for instances.
• Non-exported fields (should they be accessible? For this challenge, assume we can access them for demonstration, but acknowledge this is a limitation of standard Go reflection).
• Methods with no arguments or no return values.
• Methods with varying numbers of arguments and return values.
• Calling reflection functions on primitive types (int, string, etc.).
• Trying to set fields on immutable types or values.

Examples

Example 1: Struct Inspection and Field Access

Input:
type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}
inspectionResult := Inspect(p)

// Then, to get the Name field:
nameValue := GetField(p, "Name")

// And to set the Age field:
SetField(p, "Age", 31)

Output:
// inspectionResult should contain information about Person struct,
// with fields "Name" (string) and "Age" (int).
// nameValue should be "Alice".
// After SetField, p.Age should be 31.

Example 2: Method Invocation

Input:
type Calculator struct {
    Value int
}
func (c *Calculator) Add(x int) int {
    c.Value += x
    return c.Value
}
calc := &Calculator{Value: 10}
results, err := InvokeMethod(calc, "Add", 5)

Output:
// results should be []interface{}{15}
// err should be nil
// calc.Value should now be 15

Example 3: Pointer Handling and Error Case

Input:
type Data struct {
    ID int
}
var d *Data // nil pointer
_, err := GetField(d, "ID") // Attempt to get field from nil pointer

Output:
// err should be a non-nil error indicating a nil pointer.

Constraints

• The solution must be written entirely in Go.
• You must use the built-in reflect package.
• The solution should aim for clarity and readability.
• No external libraries are permitted for the core reflection logic.

Notes

• The reflect package in Go allows introspection of types and values at runtime.
• Pay close attention to reflect.Value and reflect.Type for understanding and manipulating values.
• Remember that reflect.Value.CanSet() is important for determining if a field can be modified.
• When invoking methods, ensure you correctly handle the types of arguments and return values.
• Consider using reflect.PtrTo and reflect.Indirect for robust pointer handling.
• For setting fields, you will likely need to obtain a reflect.Value that is settable (e.g., by taking the address of a struct or using reflect.ValueOf(&v).Elem()).