\")\n\t\t\t}\n\n\t\t\tassert.Equal(t, strings.Trim(tt.err, \"\\n\"), err.Error())\n\t\t})\n\t}\n}\n\nfunc TestCheck_FloatVsInt(t *testing.T) {\n\ttree, err := parser.Parse(`Int + Float`)\n\trequire.NoError(t, err)\n\n\ttyp, err := checker.Check(tree, conf.New(mock.Env{}))\n\tassert.NoError(t, err)\n\tassert.Equal(t, typ.Kind(), reflect.Float64)\n}\n\nfunc TestCheck_IntSums(t *testing.T) {\n\ttree, err := parser.Parse(`Uint32 + Int32`)\n\trequire.NoError(t, err)\n\n\ttyp, err := checker.Check(tree, conf.New(mock.Env{}))\n\tassert.NoError(t, err)\n\tassert.Equal(t, typ.Kind(), reflect.Int)\n}\n\nfunc TestVisitor_ConstantNode(t *testing.T) {\n\ttree, err := parser.Parse(`re(\"[a-z]\")`)\n\trequire.NoError(t, err)\n\n\tregexValue := regexp.MustCompile(\"[a-z]\")\n\tconstNode := &ast.ConstantNode{Value: regexValue}\n\tast.Patch(&tree.Node, constNode)\n\n\t_, err = checker.Check(tree, nil)\n\tassert.NoError(t, err)\n\tassert.Equal(t, reflect.TypeOf(regexValue), tree.Node.Type())\n}\n\nfunc TestCheck_AsBool(t *testing.T) {\n\ttree, err := parser.Parse(`1+2`)\n\trequire.NoError(t, err)\n\n\tconfig := &conf.Config{}\n\texpr.AsBool()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.Error(t, err)\n\tassert.Equal(t, \"expected bool, but got int\", err.Error())\n}\n\nfunc TestCheck_AsInt64(t *testing.T) {\n\ttree, err := parser.Parse(`true`)\n\trequire.NoError(t, err)\n\n\tconfig := &conf.Config{}\n\texpr.AsInt64()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.Error(t, err)\n\tassert.Equal(t, \"expected int64, but got bool\", err.Error())\n}\n\nfunc TestCheck_TaggedFieldName(t *testing.T) {\n\ttree, err := parser.Parse(`foo.bar`)\n\trequire.NoError(t, err)\n\n\tconfig := conf.CreateNew()\n\texpr.Env(struct {\n\t\tX struct {\n\t\t\tY bool `expr:\"bar\"`\n\t\t} `expr:\"foo\"`\n\t}{})(config)\n\texpr.AsBool()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.NoError(t, err)\n}\n\nfunc TestCheck_NoConfig(t *testing.T) {\n\ttree, err := parser.Parse(`any`)\n\trequire.NoError(t, err)\n\n\t_, err = checker.Check(tree, conf.CreateNew())\n\tassert.NoError(t, err)\n}\n\nfunc TestCheck_AllowUndefinedVariables(t *testing.T) {\n\ttype Env struct {\n\t\tA int\n\t}\n\n\ttree, err := parser.Parse(`Any + fn()`)\n\trequire.NoError(t, err)\n\n\tconfig := conf.New(Env{})\n\texpr.AllowUndefinedVariables()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.NoError(t, err)\n}\n\nfunc TestCheck_AllowUndefinedVariables_DefaultType(t *testing.T) {\n\tenv := map[string]bool{}\n\n\ttree, err := parser.Parse(`Any`)\n\trequire.NoError(t, err)\n\n\tconfig := conf.New(env)\n\texpr.AllowUndefinedVariables()(config)\n\texpr.AsBool()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.NoError(t, err)\n}\n\nfunc TestCheck_AllowUndefinedVariables_OptionalChaining(t *testing.T) {\n\ttype Env struct{}\n\n\ttree, err := parser.Parse(\"Not?.A.B == nil\")\n\trequire.NoError(t, err)\n\n\tconfig := conf.New(Env{})\n\texpr.AllowUndefinedVariables()(config)\n\n\t_, err = checker.Check(tree, config)\n\tassert.NoError(t, err)\n}\n\nfunc TestCheck_PointerNode(t *testing.T) {\n\t_, err := checker.Check(&parser.Tree{Node: &ast.PointerNode{}}, nil)\n\tassert.Error(t, err)\n\tassert.Contains(t, err.Error(), \"cannot use pointer accessor outside predicate\")\n}\n\nfunc TestCheck_TypeWeights(t *testing.T) {\n\ttypes := map[string]any{\n\t\t\"Uint\": uint(1),\n\t\t\"Uint8\": uint8(2),\n\t\t\"Uint16\": uint16(3),\n\t\t\"Uint32\": uint32(4),\n\t\t\"Uint64\": uint64(5),\n\t\t\"Int\": 6,\n\t\t\"Int8\": int8(7),\n\t\t\"Int16\": int16(8),\n\t\t\"Int32\": int32(9),\n\t\t\"Int64\": int64(10),\n\t\t\"Float32\": float32(11),\n\t\t\"Float64\": float64(12),\n\t}\n\tc := new(checker.Checker)\n\tfor a := range types {\n\t\tfor b := range types {\n\t\t\ttree, err := parser.Parse(fmt.Sprintf(\"%s + %s\", a, b))\n\t\t\trequire.NoError(t, err)\n\n\t\t\tconfig := conf.New(types)\n\n\t\t\t_, err = c.Check(tree, config)\n\t\t\trequire.NoError(t, err)\n\t\t}\n\t}\n}\n\nfunc TestCheck_works_with_nil_types(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"null\": nil,\n\t}\n\n\ttree, err := parser.Parse(\"null\")\n\trequire.NoError(t, err)\n\n\t_, err = checker.Check(tree, conf.New(env))\n\trequire.NoError(t, err)\n}\n\nfunc TestCheck_cast_to_expected_works_with_interface(t *testing.T) {\n\tt.Run(\"float64\", func(t *testing.T) {\n\t\ttype Env struct {\n\t\t\tAny any\n\t\t}\n\n\t\ttree, err := parser.Parse(\"Any\")\n\t\trequire.NoError(t, err)\n\n\t\tconfig := conf.New(Env{})\n\t\texpr.AsFloat64()(config)\n\t\texpr.AsAny()(config)\n\n\t\t_, err = checker.Check(tree, config)\n\t\trequire.NoError(t, err)\n\t})\n\n\tt.Run(\"kind\", func(t *testing.T) {\n\t\tenv := map[string]any{\n\t\t\t\"Any\": any(\"foo\"),\n\t\t}\n\n\t\ttree, err := parser.Parse(\"Any\")\n\t\trequire.NoError(t, err)\n\n\t\tconfig := conf.New(env)\n\t\texpr.AsKind(reflect.String)(config)\n\n\t\t_, err = checker.Check(tree, config)\n\t\trequire.NoError(t, err)\n\t})\n}\n\nfunc TestCheck_operator_in_works_with_interfaces(t *testing.T) {\n\ttree, err := parser.Parse(`'Tom' in names`)\n\trequire.NoError(t, err)\n\n\tconfig := conf.New(nil)\n\texpr.AllowUndefinedVariables()(config)\n\n\t_, err = checker.Check(tree, config)\n\trequire.NoError(t, err)\n}\n\nfunc TestCheck_Function_types_are_checked(t *testing.T) {\n\tadd := expr.Function(\n\t\t\"add\",\n\t\tfunc(p ...any) (any, error) {\n\t\t\tout := 0\n\t\t\tfor _, each := range p {\n\t\t\t\tout += each.(int)\n\t\t\t}\n\t\t\treturn out, nil\n\t\t},\n\t\tnew(func(int) int),\n\t\tnew(func(int, int) int),\n\t\tnew(func(int, int, int) int),\n\t\tnew(func(...int) int),\n\t)\n\n\tconfig := conf.CreateNew()\n\tadd(config)\n\tc := new(checker.Checker)\n\n\ttests := []string{\n\t\t\"add(1)\",\n\t\t\"add(1, 2)\",\n\t\t\"add(1, 2, 3)\",\n\t\t\"add(1, 2, 3, 4)\",\n\t}\n\tfor _, test := range tests {\n\t\tt.Run(test, func(t *testing.T) {\n\t\t\ttree, err := parser.Parse(test)\n\t\t\trequire.NoError(t, err)\n\n\t\t\t_, err = c.Check(tree, config)\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, reflect.Int, tree.Node.Type().Kind())\n\t\t})\n\t}\n\n\tt.Run(\"errors\", func(t *testing.T) {\n\t\ttree, err := parser.Parse(\"add(1, '2')\")\n\t\trequire.NoError(t, err)\n\n\t\t_, err = c.Check(tree, config)\n\t\trequire.Error(t, err)\n\t\trequire.Equal(t, \"cannot use string as argument (type int) to call add (1:8)\\n | add(1, '2')\\n | .......^\", err.Error())\n\t})\n}\n\nfunc TestCheck_Function_without_types(t *testing.T) {\n\tadd := expr.Function(\n\t\t\"add\",\n\t\tfunc(p ...any) (any, error) {\n\t\t\tout := 0\n\t\t\tfor _, each := range p {\n\t\t\t\tout += each.(int)\n\t\t\t}\n\t\t\treturn out, nil\n\t\t},\n\t)\n\n\ttree, err := parser.Parse(\"add(1, 2, 3)\")\n\trequire.NoError(t, err)\n\n\tconfig := conf.CreateNew()\n\tadd(config)\n\n\t_, err = checker.Check(tree, config)\n\trequire.NoError(t, err)\n\trequire.Equal(t, reflect.Interface, tree.Node.Type().Kind())\n}\n\nfunc TestCheck_dont_panic_on_nil_arguments_for_builtins(t *testing.T) {\n\ttests := []string{\n\t\t\"len(nil)\",\n\t\t\"abs(nil)\",\n\t\t\"int(nil)\",\n\t\t\"float(nil)\",\n\t}\n\tfor _, test := range tests {\n\t\tt.Run(test, func(t *testing.T) {\n\t\t\ttree, err := parser.Parse(test)\n\t\t\trequire.NoError(t, err)\n\n\t\t\t_, err = checker.Check(tree, conf.New(nil))\n\t\t\trequire.Error(t, err)\n\t\t})\n\t}\n}\n\nfunc TestCheck_do_not_override_params_for_functions(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": func(p string) string {\n\t\t\treturn \"foo\"\n\t\t},\n\t}\n\tconfig := conf.New(env)\n\texpr.Function(\n\t\t\"bar\",\n\t\tfunc(p ...any) (any, error) {\n\t\t\treturn p[0].(string), nil\n\t\t},\n\t\tnew(func(string) string),\n\t)(config)\n\tconfig.Check()\n\n\tt.Run(\"func from env\", func(t *testing.T) {\n\t\ttree, err := parser.Parse(\"foo(1)\")\n\t\trequire.NoError(t, err)\n\n\t\t_, err = checker.Check(tree, config)\n\t\trequire.Error(t, err)\n\t\trequire.Contains(t, err.Error(), \"cannot use int as argument\")\n\t})\n\n\tt.Run(\"func from function\", func(t *testing.T) {\n\t\ttree, err := parser.Parse(\"bar(1)\")\n\t\trequire.NoError(t, err)\n\n\t\t_, err = checker.Check(tree, config)\n\t\trequire.Error(t, err)\n\t\trequire.Contains(t, err.Error(), \"cannot use int as argument\")\n\t})\n}\n\nfunc TestCheck_env_keyword(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"num\": 42,\n\t\t\"str\": \"foo\",\n\t\t\"name\": \"str\",\n\t}\n\n\ttests := []struct {\n\t\tinput string\n\t\twant reflect.Kind\n\t}{\n\t\t{`$env['str']`, reflect.String},\n\t\t{`$env['num']`, reflect.Int},\n\t\t{`$env[name]`, reflect.Interface},\n\t}\n\n\tc := new(checker.Checker)\n\tfor _, test := range tests {\n\t\tt.Run(test.input, func(t *testing.T) {\n\t\t\ttree, err := parser.Parse(test.input)\n\t\t\trequire.NoError(t, err)\n\n\t\t\trtype, err := c.Check(tree, conf.New(env))\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.True(t, rtype.Kind() == test.want, fmt.Sprintf(\"expected %s, got %s\", test.want, rtype.Kind()))\n\t\t})\n\t}\n}\n\nfunc TestCheck_builtin_without_call(t *testing.T) {\n\ttests := []struct {\n\t\tinput string\n\t\terr string\n\t}{\n\t\t{`len + 1`, \"invalid operation: + (mismatched types func(...interface {}) (interface {}, error) and int) (1:5)\\n | len + 1\\n | ....^\"},\n\t\t{`string.A`, \"type func(interface {}) string has no field A (1:8)\\n | string.A\\n | .......^\"},\n\t}\n\n\tc := new(checker.Checker)\n\tfor _, test := range tests {\n\t\tt.Run(test.input, func(t *testing.T) {\n\t\t\ttree, err := parser.Parse(test.input)\n\t\t\trequire.NoError(t, err)\n\n\t\t\t_, err = c.Check(tree, conf.New(nil))\n\t\t\trequire.Error(t, err)\n\t\t\trequire.Equal(t, test.err, err.Error())\n\t\t})\n\t}\n}\n\nfunc TestCheck_EmbeddedInterface(t *testing.T) {\n\tt.Run(\"embedded interface lookup returns compile-error not panic\", func(t *testing.T) {\n\t\ttype Env struct {\n\t\t\tcontext.Context\n\t\t\tCountry string\n\t\t}\n\t\ttype Wrapper struct {\n\t\t\tCtx Env\n\t\t}\n\n\t\tconfig := conf.New(Wrapper{\n\t\t\tCtx: Env{\n\t\t\t\tContext: context.Background(),\n\t\t\t\tCountry: \"TR\",\n\t\t\t},\n\t\t})\n\t\texpr.WithContext(\"Ctx\")(config)\n\n\t\t_, err := checker.ParseCheck(\"Ctx.C\", config)\n\t\trequire.Error(t, err)\n\t\trequire.Contains(t, err.Error(), \"has no field C\")\n\t})\n}\n\nfunc TestCheck_types(t *testing.T) {\n\tenv := types.Map{\n\t\t\"foo\": types.Map{\n\t\t\t\"bar\": types.Map{\n\t\t\t\t\"baz\": types.String,\n\t\t\t\ttypes.Extra: types.String,\n\t\t\t},\n\t\t},\n\t\t\"arr\": types.Array(types.Map{\n\t\t\t\"value\": types.String,\n\t\t}),\n\t\ttypes.Extra: types.Any,\n\t}\n\n\tnoerr := \"no error\"\n\ttests := []struct {\n\t\tcode string\n\t\terr string\n\t}{\n\t\t{`unknown`, noerr},\n\t\t{`[unknown + 42, another_unknown + \"foo\"]`, noerr},\n\t\t{`foo.bar.baz > 0`, `invalid operation: > (mismatched types string and int)`},\n\t\t{`foo.unknown.baz`, `unknown field unknown (1:5)`},\n\t\t{`foo.bar.unknown`, noerr},\n\t\t{`foo.bar.unknown + 42`, `invalid operation: + (mismatched types string and int)`},\n\t\t{`[foo] | map(.unknown)`, `unknown field unknown`},\n\t\t{`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`},\n\t\t{`arr | filter(.value > 0)`, `invalid operation: > (mismatched types string and int)`},\n\t\t{`arr | filter(.value contains \"a\") | filter(.value == 0)`, `invalid operation: == (mismatched types string and int)`},\n\t}\n\n\tc := new(checker.Checker)\n\tfor _, test := range tests {\n\t\tt.Run(test.code, func(t *testing.T) {\n\t\t\ttree, err := parser.Parse(test.code)\n\t\t\trequire.NoError(t, err)\n\n\t\t\tconfig := conf.New(env)\n\t\t\t_, err = c.Check(tree, config)\n\t\t\tif test.err == noerr {\n\t\t\t\trequire.NoError(t, err)\n\t\t\t} else {\n\t\t\t\trequire.Error(t, err)\n\t\t\t\trequire.Contains(t, err.Error(), test.err)\n\t\t\t}\n\t\t})\n\t}\n}\n"
},
{
"path": "checker/info.go",
"content": "package checker\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/expr-lang/expr/ast\"\n\t. \"github.com/expr-lang/expr/checker/nature\"\n\t\"github.com/expr-lang/expr/vm\"\n)\n\nfunc FieldIndex(c *Cache, env Nature, node ast.Node) (bool, []int, string) {\n\tswitch n := node.(type) {\n\tcase *ast.IdentifierNode:\n\t\tif idx, ok := env.FieldIndex(c, n.Value); ok {\n\t\t\treturn true, idx, n.Value\n\t\t}\n\tcase *ast.MemberNode:\n\t\tbase := n.Node.Nature().Deref(c)\n\t\tif base.Kind == reflect.Struct {\n\t\t\tif prop, ok := n.Property.(*ast.StringNode); ok {\n\t\t\t\tif idx, ok := base.FieldIndex(c, prop.Value); ok {\n\t\t\t\t\treturn true, idx, prop.Value\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn false, nil, \"\"\n}\n\nfunc MethodIndex(c *Cache, env Nature, node ast.Node) (bool, int, string) {\n\tswitch n := node.(type) {\n\tcase *ast.IdentifierNode:\n\t\tif env.Kind == reflect.Struct {\n\t\t\tif m, ok := env.Get(c, n.Value); ok && m.TypeData != nil {\n\t\t\t\treturn m.Method, m.MethodIndex, n.Value\n\t\t\t}\n\t\t}\n\tcase *ast.MemberNode:\n\t\tif name, ok := n.Property.(*ast.StringNode); ok {\n\t\t\tbase := n.Node.Type()\n\t\t\tif base != nil && base.Kind() != reflect.Interface {\n\t\t\t\tif m, ok := base.MethodByName(name.Value); ok {\n\t\t\t\t\treturn true, m.Index, name.Value\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn false, 0, \"\"\n}\n\nfunc TypedFuncIndex(fn reflect.Type, method bool) (int, bool) {\n\tif fn == nil {\n\t\treturn 0, false\n\t}\n\tif fn.Kind() != reflect.Func {\n\t\treturn 0, false\n\t}\n\t// OnCallTyped doesn't work for functions with variadic arguments.\n\tif fn.IsVariadic() {\n\t\treturn 0, false\n\t}\n\t// OnCallTyped doesn't work named function, like `type MyFunc func() int`.\n\tif fn.PkgPath() != \"\" { // If PkgPath() is not empty, it means that function is named.\n\t\treturn 0, false\n\t}\n\n\tfnNumIn := fn.NumIn()\n\tfnInOffset := 0\n\tif method {\n\t\tfnNumIn--\n\t\tfnInOffset = 1\n\t}\n\nfuncTypes:\n\tfor i := range vm.FuncTypes {\n\t\tif i == 0 {\n\t\t\tcontinue\n\t\t}\n\t\ttyped := reflect.ValueOf(vm.FuncTypes[i]).Elem().Type()\n\t\tif typed.Kind() != reflect.Func {\n\t\t\tcontinue\n\t\t}\n\t\tif typed.NumOut() != fn.NumOut() {\n\t\t\tcontinue\n\t\t}\n\t\tfor j := 0; j < typed.NumOut(); j++ {\n\t\t\tif typed.Out(j) != fn.Out(j) {\n\t\t\t\tcontinue funcTypes\n\t\t\t}\n\t\t}\n\t\tif typed.NumIn() != fnNumIn {\n\t\t\tcontinue\n\t\t}\n\t\tfor j := 0; j < typed.NumIn(); j++ {\n\t\t\tif typed.In(j) != fn.In(j+fnInOffset) {\n\t\t\t\tcontinue funcTypes\n\t\t\t}\n\t\t}\n\t\treturn i, true\n\t}\n\treturn 0, false\n}\n\nfunc IsFastFunc(fn reflect.Type, method bool) bool {\n\tif fn == nil {\n\t\treturn false\n\t}\n\tif fn.Kind() != reflect.Func {\n\t\treturn false\n\t}\n\tnumIn := 1\n\tif method {\n\t\tnumIn = 2\n\t}\n\tif fn.IsVariadic() &&\n\t\tfn.NumIn() == numIn &&\n\t\tfn.NumOut() == 1 &&\n\t\tfn.Out(0).Kind() == reflect.Interface {\n\t\trest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods\n\t\tif rest != nil && rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n"
},
{
"path": "checker/info_test.go",
"content": "package checker_test\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/expr-lang/expr/internal/testify/require\"\n\n\t\"github.com/expr-lang/expr/checker\"\n\t\"github.com/expr-lang/expr/test/mock\"\n)\n\nfunc TestTypedFuncIndex(t *testing.T) {\n\tfn := func() time.Duration {\n\t\treturn 1 * time.Second\n\t}\n\tindex, ok := checker.TypedFuncIndex(reflect.TypeOf(fn), false)\n\trequire.True(t, ok)\n\trequire.Equal(t, 1, index)\n}\n\nfunc TestTypedFuncIndex_excludes_named_functions(t *testing.T) {\n\tvar fn mock.MyFunc\n\n\t_, ok := checker.TypedFuncIndex(reflect.TypeOf(fn), false)\n\trequire.False(t, ok)\n}\n"
},
{
"path": "checker/nature/nature.go",
"content": "package nature\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"time\"\n\n\t\"github.com/expr-lang/expr/builtin\"\n\t\"github.com/expr-lang/expr/internal/deref\"\n)\n\nvar (\n\tintType = reflect.TypeOf(0)\n\tfloatType = reflect.TypeOf(float64(0))\n\tarrayType = reflect.TypeOf([]any{})\n\tbyteSliceType = reflect.TypeOf([]byte{})\n\ttimeType = reflect.TypeOf(time.Time{})\n\tdurationType = reflect.TypeOf(time.Duration(0))\n\n\tbuiltinInt = map[reflect.Type]struct{}{\n\t\treflect.TypeOf(int(0)): {},\n\t\treflect.TypeOf(int8(0)): {},\n\t\treflect.TypeOf(int16(0)): {},\n\t\treflect.TypeOf(int32(0)): {},\n\t\treflect.TypeOf(int64(0)): {},\n\t\treflect.TypeOf(uintptr(0)): {},\n\t\treflect.TypeOf(uint(0)): {},\n\t\treflect.TypeOf(uint8(0)): {},\n\t\treflect.TypeOf(uint16(0)): {},\n\t\treflect.TypeOf(uint32(0)): {},\n\t\treflect.TypeOf(uint64(0)): {},\n\t}\n\tbuiltinFloat = map[reflect.Type]struct{}{\n\t\treflect.TypeOf(float32(0)): {},\n\t\treflect.TypeOf(float64(0)): {},\n\t}\n)\n\ntype NatureCheck int\n\nconst (\n\t_ NatureCheck = iota\n\tBoolCheck\n\tStringCheck\n\tIntegerCheck\n\tNumberCheck\n\tMapCheck\n\tArrayCheck\n\tTimeCheck\n\tDurationCheck\n)\n\ntype Nature struct {\n\t// The order of the fields matter, check alignment before making changes.\n\n\tType reflect.Type // Type of the value. If nil, then value is unknown.\n\tKind reflect.Kind // Kind of the value.\n\n\t*TypeData\n\n\t// Ref is a reference used for multiple, disjoint purposes. When the Nature\n\t// is for a:\n\t//\t- Predicate: then Ref is the nature of the Out of the predicate.\n\t//\t- Array-like types: then Ref is the Elem nature of array type (usually Type is []any, but ArrayOf can be any nature).\n\tRef *Nature\n\n\tNil bool // If value is nil.\n\tStrict bool // If map is types.StrictMap.\n\tMethod bool // If value retrieved from method. Usually used to determine amount of in arguments.\n\tIsInteger bool // If it's a builtin integer or unsigned integer type.\n\tIsFloat bool // If it's a builtin float type.\n}\n\ntype TypeData struct {\n\tmethodset *methodset // optional to avoid the map in *Cache\n\n\t*structData\n\n\t// map-only data\n\tFields map[string]Nature // Fields of map type.\n\tDefaultMapValue *Nature // Default value of map type.\n\n\t// callable-only data\n\tFunc *builtin.Function // Used to pass function type from callee to CallNode.\n\tMethodIndex int // Index of method in type.\n\tinElem, outZero *Nature\n\tnumIn, numOut int\n\n\tisVariadic bool\n\tisVariadicSet bool\n\tnumInSet bool\n\tnumOutSet bool\n}\n\n// Cache is a shared cache of type information. It is only used in the stages\n// where type information becomes relevant, so packages like ast, parser, types,\n// and lexer do not need to use the cache because they don't need any service\n// from the Nature type, they only describe. However, when receiving a Nature\n// from one of those packages, the cache must be set immediately.\ntype Cache struct {\n\tmethods map[reflect.Type]*methodset\n\tstructs map[reflect.Type]Nature\n}\n\n// NatureOf returns a Nature describing \"i\". If \"i\" is nil then it returns a\n// Nature describing the value \"nil\".\nfunc (c *Cache) NatureOf(i any) Nature {\n\t// reflect.TypeOf(nil) returns nil, but in FromType we want to differentiate\n\t// what nil means for us\n\tif i == nil {\n\t\treturn Nature{Nil: true}\n\t}\n\treturn c.FromType(reflect.TypeOf(i))\n}\n\n// FromType returns a Nature describing a value of type \"t\". If \"t\" is nil then\n// it returns a Nature describing an unknown value.\nfunc (c *Cache) FromType(t reflect.Type) Nature {\n\tif t == nil {\n\t\treturn Nature{}\n\t}\n\tvar td *TypeData\n\tvar isInteger, isFloat bool\n\tk := t.Kind()\n\tswitch k {\n\tcase reflect.Struct:\n\t\t// c can be nil when we call the package function FromType, which uses a\n\t\t// nil *Cache to call this method.\n\t\tif c != nil {\n\t\t\treturn c.getStruct(t)\n\t\t}\n\t\tfallthrough\n\tcase reflect.Func:\n\t\ttd = new(TypeData)\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,\n\t\treflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:\n\t\t_, isInteger = builtinInt[t]\n\tcase reflect.Float32, reflect.Float64:\n\t\t_, isFloat = builtinFloat[t]\n\t}\n\treturn Nature{\n\t\tType: t,\n\t\tKind: k,\n\t\tTypeData: td,\n\t\tIsInteger: isInteger,\n\t\tIsFloat: isFloat,\n\t}\n}\n\nfunc (c *Cache) getStruct(t reflect.Type) Nature {\n\tif c.structs == nil {\n\t\tc.structs = map[reflect.Type]Nature{}\n\t} else if nt, ok := c.structs[t]; ok {\n\t\treturn nt\n\t}\n\tnt := Nature{\n\t\tType: t,\n\t\tKind: reflect.Struct,\n\t\tTypeData: &TypeData{\n\t\t\tstructData: &structData{\n\t\t\t\trType: t,\n\t\t\t\tnumField: t.NumField(),\n\t\t\t\tanonIdx: -1, // do not lookup embedded fields yet\n\t\t\t},\n\t\t},\n\t}\n\tc.structs[t] = nt\n\treturn nt\n}\n\nfunc (c *Cache) getMethodset(t reflect.Type, k reflect.Kind) *methodset {\n\tif t == nil || c == nil {\n\t\treturn nil\n\t}\n\tif c.methods == nil {\n\t\tc.methods = map[reflect.Type]*methodset{\n\t\t\tt: nil,\n\t\t}\n\t} else if s, ok := c.methods[t]; ok {\n\t\treturn s\n\t}\n\tnumMethod := t.NumMethod()\n\tif numMethod < 1 {\n\t\tc.methods[t] = nil // negative cache\n\t\treturn nil\n\t}\n\ts := &methodset{\n\t\trType: t,\n\t\tkind: k,\n\t\tnumMethod: numMethod,\n\t}\n\tc.methods[t] = s\n\treturn s\n}\n\n// NatureOf calls NatureOf on a nil *Cache. See the comment on Cache.\nfunc NatureOf(i any) Nature {\n\tvar c *Cache\n\treturn c.NatureOf(i)\n}\n\n// FromType calls FromType on a nil *Cache. See the comment on Cache.\nfunc FromType(t reflect.Type) Nature {\n\tvar c *Cache\n\treturn c.FromType(t)\n}\n\nfunc ArrayFromType(c *Cache, t reflect.Type) Nature {\n\telem := c.FromType(t)\n\tnt := c.FromType(arrayType)\n\tnt.Ref = &elem\n\treturn nt\n}\n\nfunc (n *Nature) IsAny(c *Cache) bool {\n\treturn n.Type != nil && n.Kind == reflect.Interface && n.NumMethods(c) == 0\n}\n\nfunc (n *Nature) IsUnknown(c *Cache) bool {\n\treturn n.Type == nil && !n.Nil || n.IsAny(c)\n}\n\nfunc (n *Nature) String() string {\n\tif n.Type != nil {\n\t\treturn n.Type.String()\n\t}\n\treturn \"unknown\"\n}\n\nfunc (n *Nature) Deref(c *Cache) Nature {\n\tt, _, changed := deref.TypeKind(n.Type, n.Kind)\n\tif !changed {\n\t\treturn *n\n\t}\n\treturn c.FromType(t)\n}\n\nfunc (n *Nature) Key(c *Cache) Nature {\n\tif n.Kind == reflect.Map {\n\t\treturn c.FromType(n.Type.Key())\n\t}\n\treturn Nature{}\n}\n\nfunc (n *Nature) Elem(c *Cache) Nature {\n\tswitch n.Kind {\n\tcase reflect.Ptr:\n\t\treturn c.FromType(n.Type.Elem())\n\tcase reflect.Map:\n\t\tif n.TypeData != nil && n.DefaultMapValue != nil {\n\t\t\treturn *n.DefaultMapValue\n\t\t}\n\t\treturn c.FromType(n.Type.Elem())\n\tcase reflect.Slice, reflect.Array:\n\t\tif n.Ref != nil {\n\t\t\treturn *n.Ref\n\t\t}\n\t\treturn c.FromType(n.Type.Elem())\n\t}\n\treturn Nature{}\n}\n\nfunc (n *Nature) AssignableTo(nt Nature) bool {\n\tif n.Nil {\n\t\tswitch nt.Kind {\n\t\tcase reflect.Pointer, reflect.Interface, reflect.Chan, reflect.Func,\n\t\t\treflect.Map, reflect.Slice:\n\t\t\t// nil can be assigned to these kinds\n\t\t\treturn true\n\t\t}\n\t}\n\tif n.Type == nil || nt.Type == nil ||\n\t\tn.Kind != nt.Kind && nt.Kind != reflect.Interface {\n\t\treturn false\n\t}\n\treturn n.Type.AssignableTo(nt.Type)\n}\n\nfunc (n *Nature) getMethodset(c *Cache) *methodset {\n\tif n.TypeData != nil && n.TypeData.methodset != nil {\n\t\treturn n.TypeData.methodset\n\t}\n\ts := c.getMethodset(n.Type, n.Kind)\n\tif n.TypeData != nil {\n\t\tn.TypeData.methodset = s // cache locally if possible\n\t}\n\treturn s\n}\n\nfunc (n *Nature) NumMethods(c *Cache) int {\n\tif s := n.getMethodset(c); s != nil {\n\t\treturn s.numMethod\n\t}\n\treturn 0\n}\n\nfunc (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) {\n\tif s := n.getMethodset(c); s != nil {\n\t\tif m := s.method(c, name); m != nil {\n\t\t\treturn m.nature, true\n\t\t}\n\t}\n\treturn Nature{}, false\n}\n\nfunc (n *Nature) NumIn() int {\n\tif n.numInSet {\n\t\treturn n.numIn\n\t}\n\tn.numInSet = true\n\tn.numIn = n.Type.NumIn()\n\treturn n.numIn\n}\n\nfunc (n *Nature) InElem(c *Cache, i int) Nature {\n\tif n.inElem == nil {\n\t\tn2 := c.FromType(n.Type.In(i))\n\t\tn2 = n2.Elem(c)\n\t\tn.inElem = &n2\n\t}\n\treturn *n.inElem\n}\n\nfunc (n *Nature) In(c *Cache, i int) Nature {\n\treturn c.FromType(n.Type.In(i))\n}\n\nfunc (n *Nature) IsFirstArgUnknown(c *Cache) bool {\n\tif n.Type != nil {\n\t\tn2 := c.FromType(n.Type.In(0))\n\t\treturn n2.IsUnknown(c)\n\t}\n\treturn false\n}\n\nfunc (n *Nature) NumOut() int {\n\tif n.numOutSet {\n\t\treturn n.numOut\n\t}\n\tn.numOutSet = true\n\tn.numOut = n.Type.NumOut()\n\treturn n.numOut\n}\n\nfunc (n *Nature) Out(c *Cache, i int) Nature {\n\tif i != 0 {\n\t\treturn n.out(c, i)\n\t}\n\tif n.outZero != nil {\n\t\treturn *n.outZero\n\t}\n\tnt := n.out(c, 0)\n\tn.outZero = &nt\n\treturn nt\n}\n\nfunc (n *Nature) out(c *Cache, i int) Nature {\n\tif n.Type == nil {\n\t\treturn Nature{}\n\t}\n\treturn c.FromType(n.Type.Out(i))\n}\n\nfunc (n *Nature) IsVariadic() bool {\n\tif n.isVariadicSet {\n\t\treturn n.isVariadic\n\t}\n\tn.isVariadicSet = true\n\tn.isVariadic = n.Type.IsVariadic()\n\treturn n.isVariadic\n}\n\nfunc (n *Nature) FieldByName(c *Cache, name string) (Nature, bool) {\n\tif n.Kind != reflect.Struct {\n\t\treturn Nature{}, false\n\t}\n\tvar sd *structData\n\tif n.TypeData != nil && n.structData != nil {\n\t\tsd = n.structData\n\t} else {\n\t\tsd = c.getStruct(n.Type).structData\n\t}\n\tif sf := sd.structField(c, nil, name); sf != nil {\n\t\treturn sf.Nature, true\n\t}\n\treturn Nature{}, false\n}\n\nfunc (n *Nature) IsFastMap() bool {\n\treturn n.Type != nil &&\n\t\tn.Type.Kind() == reflect.Map &&\n\t\tn.Type.Key().Kind() == reflect.String &&\n\t\tn.Type.Elem().Kind() == reflect.Interface\n}\n\nfunc (n *Nature) Get(c *Cache, name string) (Nature, bool) {\n\tif n.Kind == reflect.Map && n.TypeData != nil {\n\t\tf, ok := n.Fields[name]\n\t\treturn f, ok\n\t}\n\treturn n.getSlow(c, name)\n}\n\nfunc (n *Nature) getSlow(c *Cache, name string) (Nature, bool) {\n\tif nt, ok := n.MethodByName(c, name); ok {\n\t\treturn nt, true\n\t}\n\tt, k, changed := deref.TypeKind(n.Type, n.Kind)\n\tif k == reflect.Struct {\n\t\tvar sd *structData\n\t\tif changed {\n\t\t\tsd = c.getStruct(t).structData\n\t\t} else {\n\t\t\tsd = n.structData\n\t\t}\n\t\tif sf := sd.structField(c, nil, name); sf != nil {\n\t\t\treturn sf.Nature, true\n\t\t}\n\t}\n\treturn Nature{}, false\n}\n\nfunc (n *Nature) FieldIndex(c *Cache, name string) ([]int, bool) {\n\tif n.Kind != reflect.Struct {\n\t\treturn nil, false\n\t}\n\tif sf := n.structField(c, nil, name); sf != nil {\n\t\treturn sf.Index, true\n\t}\n\treturn nil, false\n}\n\nfunc (n *Nature) All(c *Cache) map[string]Nature {\n\ttable := make(map[string]Nature)\n\n\tif n.Type == nil {\n\t\treturn table\n\t}\n\n\tfor i := 0; i < n.NumMethods(c); i++ {\n\t\tmethod := n.Type.Method(i)\n\t\tnt := c.FromType(method.Type)\n\t\tif nt.TypeData == nil {\n\t\t\tnt.TypeData = new(TypeData)\n\t\t}\n\t\tnt.Method = true\n\t\tnt.MethodIndex = method.Index\n\t\ttable[method.Name] = nt\n\t}\n\n\tt := deref.Type(n.Type)\n\n\tswitch t.Kind() {\n\tcase reflect.Struct:\n\t\tfor name, nt := range StructFields(c, t) {\n\t\t\tif _, ok := table[name]; ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\ttable[name] = nt\n\t\t}\n\n\tcase reflect.Map:\n\t\tif n.TypeData != nil {\n\t\t\tfor key, nt := range n.Fields {\n\t\t\t\tif _, ok := table[key]; ok {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\ttable[key] = nt\n\t\t\t}\n\t\t}\n\t}\n\n\treturn table\n}\n\nfunc (n *Nature) IsNumber() bool {\n\treturn n.IsInteger || n.IsFloat\n}\n\nfunc (n *Nature) PromoteNumericNature(c *Cache, rhs Nature) Nature {\n\tif n.IsUnknown(c) || rhs.IsUnknown(c) {\n\t\treturn Nature{}\n\t}\n\tif n.IsFloat || rhs.IsFloat {\n\t\treturn c.FromType(floatType)\n\t}\n\treturn c.FromType(intType)\n}\n\nfunc (n *Nature) IsTime() bool {\n\treturn n.Type == timeType\n}\n\nfunc (n *Nature) IsDuration() bool {\n\treturn n.Type == durationType\n}\n\nfunc (n *Nature) IsBool() bool {\n\treturn n.Kind == reflect.Bool\n}\n\nfunc (n *Nature) IsString() bool {\n\treturn n.Kind == reflect.String\n}\n\nfunc (n *Nature) IsByteSlice() bool {\n\treturn n.Type == byteSliceType\n}\n\nfunc (n *Nature) IsArray() bool {\n\treturn n.Kind == reflect.Slice || n.Kind == reflect.Array\n}\n\nfunc (n *Nature) IsMap() bool {\n\treturn n.Kind == reflect.Map\n}\n\nfunc (n *Nature) IsStruct() bool {\n\treturn n.Kind == reflect.Struct\n}\n\nfunc (n *Nature) IsFunc() bool {\n\treturn n.Kind == reflect.Func\n}\n\nfunc (n *Nature) IsPointer() bool {\n\treturn n.Kind == reflect.Ptr\n}\n\nfunc (n *Nature) IsAnyOf(cs ...NatureCheck) bool {\n\tvar result bool\n\tfor i := 0; i < len(cs) && !result; i++ {\n\t\tswitch cs[i] {\n\t\tcase BoolCheck:\n\t\t\tresult = n.IsBool()\n\t\tcase StringCheck:\n\t\t\tresult = n.IsString()\n\t\tcase IntegerCheck:\n\t\t\tresult = n.IsInteger\n\t\tcase NumberCheck:\n\t\t\tresult = n.IsNumber()\n\t\tcase MapCheck:\n\t\t\tresult = n.IsMap()\n\t\tcase ArrayCheck:\n\t\t\tresult = n.IsArray()\n\t\tcase TimeCheck:\n\t\t\tresult = n.IsTime()\n\t\tcase DurationCheck:\n\t\t\tresult = n.IsDuration()\n\t\tdefault:\n\t\t\tpanic(fmt.Sprintf(\"unknown check value %d\", cs[i]))\n\t\t}\n\t}\n\treturn result\n}\n\nfunc (n *Nature) ComparableTo(c *Cache, rhs Nature) bool {\n\treturn n.IsUnknown(c) || rhs.IsUnknown(c) ||\n\t\tn.Nil || rhs.Nil ||\n\t\tn.IsNumber() && rhs.IsNumber() ||\n\t\tn.IsDuration() && rhs.IsDuration() ||\n\t\tn.IsTime() && rhs.IsTime() ||\n\t\tn.IsArray() && rhs.IsArray() ||\n\t\tn.AssignableTo(rhs)\n}\n\nfunc (n *Nature) MaybeCompatible(c *Cache, rhs Nature, cs ...NatureCheck) bool {\n\tnIsUnknown := n.IsUnknown(c)\n\trshIsUnknown := rhs.IsUnknown(c)\n\treturn nIsUnknown && rshIsUnknown ||\n\t\tnIsUnknown && rhs.IsAnyOf(cs...) ||\n\t\trshIsUnknown && n.IsAnyOf(cs...)\n}\n\nfunc (n *Nature) MakeArrayOf(c *Cache) Nature {\n\tnt := c.FromType(arrayType)\n\tnt.Ref = n\n\treturn nt\n}\n"
},
{
"path": "checker/nature/utils.go",
"content": "package nature\n\nimport (\n\t\"reflect\"\n\n\t\"github.com/expr-lang/expr/internal/deref\"\n)\n\nfunc fieldName(fieldName string, tag reflect.StructTag) (string, bool) {\n\tswitch taggedName := tag.Get(\"expr\"); taggedName {\n\tcase \"-\":\n\t\treturn \"\", false\n\tcase \"\":\n\t\treturn fieldName, true\n\tdefault:\n\t\treturn taggedName, true\n\t}\n}\n\ntype structData struct {\n\trType reflect.Type\n\tfields map[string]*structField\n\tnumField, ownIdx, anonIdx int\n\n\tcurParent, curChild *structData\n\tcurChildIndex []int\n}\n\ntype structField struct {\n\tNature\n\tIndex []int\n}\n\nfunc (s *structData) finished() bool {\n\treturn s.ownIdx >= s.numField && // no own fields left to visit\n\t\ts.anonIdx >= s.numField && // no embedded fields to visit\n\t\ts.curChild == nil // no child in process of visiting\n}\n\nfunc (s *structData) structField(c *Cache, parentEmbed *structData, name string) *structField {\n\tif s.fields == nil {\n\t\tif s.numField > 0 {\n\t\t\ts.fields = make(map[string]*structField, s.numField)\n\t\t}\n\t} else if f := s.fields[name]; f != nil {\n\t\treturn f\n\t}\n\tif s.finished() {\n\t\treturn nil\n\t}\n\n\t// Lookup own fields first.\n\tfor ; s.ownIdx < s.numField; s.ownIdx++ {\n\t\tfield := s.rType.Field(s.ownIdx)\n\t\tif field.Anonymous && s.anonIdx < 0 {\n\t\t\t// start iterating anon fields on the first instead of zero\n\t\t\ts.anonIdx = s.ownIdx\n\t\t}\n\t\tif !field.IsExported() {\n\t\t\tcontinue\n\t\t}\n\t\tfName, ok := fieldName(field.Name, field.Tag)\n\t\tif !ok || fName == \"\" {\n\t\t\t// name can still be empty for a type created at runtime with\n\t\t\t// reflect\n\t\t\tcontinue\n\t\t}\n\t\tnt := c.FromType(field.Type)\n\t\tsf := &structField{\n\t\t\tNature: nt,\n\t\t\tIndex: field.Index,\n\t\t}\n\t\ts.fields[fName] = sf\n\t\tif parentEmbed != nil {\n\t\t\tparentEmbed.trySet(fName, sf)\n\t\t}\n\t\tif fName == name {\n\t\t\treturn sf\n\t\t}\n\t}\n\n\tif s.curChild != nil {\n\t\tsf := s.findInEmbedded(c, parentEmbed, s.curChild, s.curChildIndex, name)\n\t\tif sf != nil {\n\t\t\treturn sf\n\t\t}\n\t}\n\n\t// Lookup embedded fields through anon own fields\n\tfor ; s.anonIdx >= 0 && s.anonIdx < s.numField; s.anonIdx++ {\n\t\tfield := s.rType.Field(s.anonIdx)\n\t\t// we do enter embedded non-exported types because they could contain\n\t\t// exported fields\n\t\tif !field.Anonymous {\n\t\t\tcontinue\n\t\t}\n\t\tt, k, _ := deref.TypeKind(field.Type, field.Type.Kind())\n\t\tif k != reflect.Struct {\n\t\t\tcontinue\n\t\t}\n\n\t\tchildEmbed := c.getStruct(t).structData\n\t\tsf := s.findInEmbedded(c, parentEmbed, childEmbed, field.Index, name)\n\t\tif sf != nil {\n\t\t\treturn sf\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc (s *structData) findInEmbedded(\n\tc *Cache,\n\tparentEmbed, childEmbed *structData,\n\tchildIndex []int,\n\tname string,\n) *structField {\n\t// Set current parent/child data. This allows trySet to handle child fields\n\t// and add them to our struct and to the parent as well if needed\n\ts.curParent = parentEmbed\n\ts.curChild = childEmbed\n\ts.curChildIndex = childIndex\n\tdefer func() {\n\t\t// Ensure to cleanup references\n\t\ts.curParent = nil\n\t\tif childEmbed.finished() {\n\t\t\t// If the child can still have more fields to explore then keep it\n\t\t\t// referened to look it up again if we need to\n\t\t\ts.curChild = nil\n\t\t\ts.curChildIndex = nil\n\t\t}\n\t}()\n\n\t// See if the child has already cached its fields. This is still important\n\t// to check even if it's the s.unfinishedEmbedded because it may have\n\t// explored new fields since the last time we visited it\n\tfor name, sf := range childEmbed.fields {\n\t\ts.trySet(name, sf)\n\t}\n\n\t// Recheck if we have what we needed from the above sync\n\tif sf := s.fields[name]; sf != nil {\n\t\treturn sf\n\t}\n\n\t// Try finding in the child again in case it hasn't finished\n\tif !childEmbed.finished() {\n\t\tif childEmbed.structField(c, s, name) != nil {\n\t\t\treturn s.fields[name]\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc (s *structData) trySet(name string, sf *structField) {\n\tif _, ok := s.fields[name]; ok {\n\t\treturn\n\t}\n\tsf = &structField{\n\t\tNature: sf.Nature,\n\t\tIndex: append(s.curChildIndex, sf.Index...),\n\t}\n\ts.fields[name] = sf\n\tif s.curParent != nil {\n\t\ts.curParent.trySet(name, sf)\n\t}\n}\n\nfunc StructFields(c *Cache, t reflect.Type) map[string]Nature {\n\ttable := make(map[string]Nature)\n\tif t == nil {\n\t\treturn table\n\t}\n\tt, k, _ := deref.TypeKind(t, t.Kind())\n\tif k == reflect.Struct {\n\t\t// lookup for a field with an empty name, which will cause to never find a\n\t\t// match, meaning everything will have been cached.\n\t\tsd := c.getStruct(t).structData\n\t\tsd.structField(c, nil, \"\")\n\t\tfor name, sf := range sd.fields {\n\t\t\ttable[name] = sf.Nature\n\t\t}\n\t}\n\treturn table\n}\n\ntype methodset struct {\n\trType reflect.Type\n\tkind reflect.Kind\n\tmethods map[string]*method\n\tnumMethod, idx int\n}\n\ntype method struct {\n\treflect.Method\n\tnature Nature\n}\n\nfunc (s *methodset) method(c *Cache, name string) *method {\n\tif s.methods == nil {\n\t\ts.methods = make(map[string]*method, s.numMethod)\n\t} else if m := s.methods[name]; m != nil {\n\t\treturn m\n\t}\n\tfor ; s.idx < s.numMethod; s.idx++ {\n\t\trm := s.rType.Method(s.idx)\n\t\tif !rm.IsExported() {\n\t\t\tcontinue\n\t\t}\n\t\tnt := c.FromType(rm.Type)\n\t\tif s.rType.Kind() != reflect.Interface {\n\t\t\tnt.Method = true\n\t\t\tnt.MethodIndex = rm.Index\n\t\t\t// In case of interface type method will not have a receiver,\n\t\t\t// and to prevent checker decreasing numbers of in arguments\n\t\t\t// return method type as not method (second argument is false).\n\n\t\t\t// Also, we can not use m.Index here, because it will be\n\t\t\t// different indexes for different types which implement\n\t\t\t// the same interface.\n\t\t}\n\t\tm := &method{\n\t\t\tMethod: rm,\n\t\t\tnature: nt,\n\t\t}\n\t\ts.methods[rm.Name] = m\n\t\tif rm.Name == name {\n\t\t\treturn m\n\t\t}\n\t}\n\treturn nil\n}\n"
},
{
"path": "compiler/compiler.go",
"content": "package compiler\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"runtime/debug\"\n\n\t\"github.com/expr-lang/expr/ast\"\n\t\"github.com/expr-lang/expr/builtin\"\n\t\"github.com/expr-lang/expr/checker\"\n\t. \"github.com/expr-lang/expr/checker/nature\"\n\t\"github.com/expr-lang/expr/conf\"\n\t\"github.com/expr-lang/expr/file\"\n\t\"github.com/expr-lang/expr/parser\"\n\t. \"github.com/expr-lang/expr/vm\"\n\t\"github.com/expr-lang/expr/vm/runtime\"\n)\n\nconst (\n\tplaceholder = 12345\n)\n\nfunc Compile(tree *parser.Tree, config *conf.Config) (program *Program, err error) {\n\tdefer func() {\n\t\tif r := recover(); r != nil {\n\t\t\terr = fmt.Errorf(\"%v\\n%s\", r, debug.Stack())\n\t\t}\n\t}()\n\n\tc := &compiler{\n\t\tconfig: config,\n\t\tlocations: make([]file.Location, 0),\n\t\tconstantsIndex: make(map[any]int),\n\t\tfunctionsIndex: make(map[string]int),\n\t\tdebugInfo: make(map[string]string),\n\t}\n\n\tif config != nil {\n\t\tc.ntCache = &c.config.NtCache\n\t} else {\n\t\tc.ntCache = new(Cache)\n\t}\n\n\tc.compile(tree.Node)\n\n\tif c.config != nil {\n\t\tswitch c.config.Expect {\n\t\tcase reflect.Int:\n\t\t\tc.emit(OpCast, 0)\n\t\tcase reflect.Int64:\n\t\t\tc.emit(OpCast, 1)\n\t\tcase reflect.Float64:\n\t\t\tc.emit(OpCast, 2)\n\t\tcase reflect.Bool:\n\t\t\tc.emit(OpCast, 3)\n\t\t}\n\t\tif c.config.Optimize {\n\t\t\tc.optimize()\n\t\t}\n\t}\n\n\tvar span *Span\n\tif len(c.spans) > 0 {\n\t\tspan = c.spans[0]\n\t}\n\n\tprogram = NewProgram(\n\t\ttree.Source,\n\t\ttree.Node,\n\t\tc.locations,\n\t\tc.variables,\n\t\tc.constants,\n\t\tc.bytecode,\n\t\tc.arguments,\n\t\tc.functions,\n\t\tc.debugInfo,\n\t\tspan,\n\t)\n\treturn\n}\n\ntype compiler struct {\n\tconfig *conf.Config\n\tntCache *Cache\n\tlocations []file.Location\n\tbytecode []Opcode\n\tvariables int\n\tscopes []scope\n\tconstants []any\n\tconstantsIndex map[any]int\n\tfunctions []Function\n\tfunctionsIndex map[string]int\n\tdebugInfo map[string]string\n\tnodes []ast.Node\n\tspans []*Span\n\tchains [][]int\n\targuments []int\n}\n\ntype scope struct {\n\tvariableName string\n\tindex int\n}\n\nfunc (c *compiler) nodeParent() ast.Node {\n\tif len(c.nodes) > 1 {\n\t\treturn c.nodes[len(c.nodes)-2]\n\t}\n\treturn nil\n}\n\nfunc (c *compiler) emitLocation(loc file.Location, op Opcode, arg int) int {\n\tc.bytecode = append(c.bytecode, op)\n\tcurrent := len(c.bytecode)\n\tc.arguments = append(c.arguments, arg)\n\tc.locations = append(c.locations, loc)\n\treturn current\n}\n\nfunc (c *compiler) emit(op Opcode, args ...int) int {\n\targ := 0\n\tif len(args) > 1 {\n\t\tpanic(\"too many arguments\")\n\t}\n\tif len(args) == 1 {\n\t\targ = args[0]\n\t}\n\tvar loc file.Location\n\tif len(c.nodes) > 0 {\n\t\tloc = c.nodes[len(c.nodes)-1].Location()\n\t}\n\treturn c.emitLocation(loc, op, arg)\n}\n\nfunc (c *compiler) emitPush(value any) int {\n\treturn c.emit(OpPush, c.addConstant(value))\n}\n\nfunc (c *compiler) addConstant(constant any) int {\n\tindexable := true\n\thash := constant\n\tswitch reflect.TypeOf(constant).Kind() {\n\tcase reflect.Slice, reflect.Map, reflect.Struct, reflect.Func:\n\t\tindexable = false\n\t}\n\tif field, ok := constant.(*runtime.Field); ok {\n\t\tindexable = true\n\t\thash = fmt.Sprintf(\"%v\", field)\n\t}\n\tif method, ok := constant.(*runtime.Method); ok {\n\t\tindexable = true\n\t\thash = fmt.Sprintf(\"%v\", method)\n\t}\n\tif indexable {\n\t\tif p, ok := c.constantsIndex[hash]; ok {\n\t\t\treturn p\n\t\t}\n\t}\n\tc.constants = append(c.constants, constant)\n\tp := len(c.constants) - 1\n\tif indexable {\n\t\tc.constantsIndex[hash] = p\n\t}\n\treturn p\n}\n\nfunc (c *compiler) addVariable(name string) int {\n\tc.variables++\n\tc.debugInfo[fmt.Sprintf(\"var_%d\", c.variables-1)] = name\n\treturn c.variables - 1\n}\n\n// emitFunction adds builtin.Function.Func to the program.functions and emits call opcode.\nfunc (c *compiler) emitFunction(fn *builtin.Function, argsLen int) {\n\tswitch argsLen {\n\tcase 0:\n\t\tc.emit(OpCall0, c.addFunction(fn.Name, fn.Func))\n\tcase 1:\n\t\tc.emit(OpCall1, c.addFunction(fn.Name, fn.Func))\n\tcase 2:\n\t\tc.emit(OpCall2, c.addFunction(fn.Name, fn.Func))\n\tcase 3:\n\t\tc.emit(OpCall3, c.addFunction(fn.Name, fn.Func))\n\tdefault:\n\t\tc.emit(OpLoadFunc, c.addFunction(fn.Name, fn.Func))\n\t\tc.emit(OpCallN, argsLen)\n\t}\n}\n\n// addFunction adds builtin.Function.Func to the program.functions and returns its index.\nfunc (c *compiler) addFunction(name string, fn Function) int {\n\tif fn == nil {\n\t\tpanic(\"function is nil\")\n\t}\n\tif p, ok := c.functionsIndex[name]; ok {\n\t\treturn p\n\t}\n\tp := len(c.functions)\n\tc.functions = append(c.functions, fn)\n\tc.functionsIndex[name] = p\n\tc.debugInfo[fmt.Sprintf(\"func_%d\", p)] = name\n\treturn p\n}\n\nfunc (c *compiler) patchJump(placeholder int) {\n\toffset := len(c.bytecode) - placeholder\n\tc.arguments[placeholder-1] = offset\n}\n\nfunc (c *compiler) calcBackwardJump(to int) int {\n\treturn len(c.bytecode) + 1 - to\n}\n\nfunc (c *compiler) compile(node ast.Node) {\n\tc.nodes = append(c.nodes, node)\n\tdefer func() {\n\t\tc.nodes = c.nodes[:len(c.nodes)-1]\n\t}()\n\n\tif c.config != nil && c.config.Profile {\n\t\tspan := &Span{\n\t\t\tName: reflect.TypeOf(node).String(),\n\t\t\tExpression: node.String(),\n\t\t}\n\t\tif len(c.spans) > 0 {\n\t\t\tprev := c.spans[len(c.spans)-1]\n\t\t\tprev.Children = append(prev.Children, span)\n\t\t}\n\t\tc.spans = append(c.spans, span)\n\t\tdefer func() {\n\t\t\tif len(c.spans) > 1 {\n\t\t\t\tc.spans = c.spans[:len(c.spans)-1]\n\t\t\t}\n\t\t}()\n\n\t\tc.emit(OpProfileStart, c.addConstant(span))\n\t\tdefer func() {\n\t\t\tc.emit(OpProfileEnd, c.addConstant(span))\n\t\t}()\n\t}\n\n\tswitch n := node.(type) {\n\tcase *ast.NilNode:\n\t\tc.NilNode(n)\n\tcase *ast.IdentifierNode:\n\t\tc.IdentifierNode(n)\n\tcase *ast.IntegerNode:\n\t\tc.IntegerNode(n)\n\tcase *ast.FloatNode:\n\t\tc.FloatNode(n)\n\tcase *ast.BoolNode:\n\t\tc.BoolNode(n)\n\tcase *ast.StringNode:\n\t\tc.StringNode(n)\n\tcase *ast.BytesNode:\n\t\tc.BytesNode(n)\n\tcase *ast.ConstantNode:\n\t\tc.ConstantNode(n)\n\tcase *ast.UnaryNode:\n\t\tc.UnaryNode(n)\n\tcase *ast.BinaryNode:\n\t\tc.BinaryNode(n)\n\tcase *ast.ChainNode:\n\t\tc.ChainNode(n)\n\tcase *ast.MemberNode:\n\t\tc.MemberNode(n)\n\tcase *ast.SliceNode:\n\t\tc.SliceNode(n)\n\tcase *ast.CallNode:\n\t\tc.CallNode(n)\n\tcase *ast.BuiltinNode:\n\t\tc.BuiltinNode(n)\n\tcase *ast.PredicateNode:\n\t\tc.PredicateNode(n)\n\tcase *ast.PointerNode:\n\t\tc.PointerNode(n)\n\tcase *ast.VariableDeclaratorNode:\n\t\tc.VariableDeclaratorNode(n)\n\tcase *ast.SequenceNode:\n\t\tc.SequenceNode(n)\n\tcase *ast.ConditionalNode:\n\t\tc.ConditionalNode(n)\n\tcase *ast.ArrayNode:\n\t\tc.ArrayNode(n)\n\tcase *ast.MapNode:\n\t\tc.MapNode(n)\n\tcase *ast.PairNode:\n\t\tc.PairNode(n)\n\tdefault:\n\t\tpanic(fmt.Sprintf(\"undefined node type (%T)\", node))\n\t}\n}\n\nfunc (c *compiler) NilNode(_ *ast.NilNode) {\n\tc.emit(OpNil)\n}\n\nfunc (c *compiler) IdentifierNode(node *ast.IdentifierNode) {\n\tif index, ok := c.lookupVariable(node.Value); ok {\n\t\tc.emit(OpLoadVar, index)\n\t\treturn\n\t}\n\tif node.Value == \"$env\" {\n\t\tc.emit(OpLoadEnv)\n\t\treturn\n\t}\n\n\tvar env Nature\n\tif c.config != nil {\n\t\tenv = c.config.Env\n\t}\n\n\tif env.IsFastMap() {\n\t\tc.emit(OpLoadFast, c.addConstant(node.Value))\n\t} else if ok, index, name := checker.FieldIndex(c.ntCache, env, node); ok {\n\t\tc.emit(OpLoadField, c.addConstant(&runtime.Field{\n\t\t\tIndex: index,\n\t\t\tPath: []string{name},\n\t\t}))\n\t} else if ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok {\n\t\tc.emit(OpLoadMethod, c.addConstant(&runtime.Method{\n\t\t\tName: name,\n\t\t\tIndex: index,\n\t\t}))\n\t} else {\n\t\tc.emit(OpLoadConst, c.addConstant(node.Value))\n\t}\n}\n\nfunc (c *compiler) IntegerNode(node *ast.IntegerNode) {\n\tt := node.Type()\n\tif t == nil {\n\t\tc.emitPush(node.Value)\n\t\treturn\n\t}\n\tswitch t.Kind() {\n\tcase reflect.Float32:\n\t\tc.emitPush(float32(node.Value))\n\tcase reflect.Float64:\n\t\tc.emitPush(float64(node.Value))\n\tcase reflect.Int:\n\t\tc.emitPush(node.Value)\n\tcase reflect.Int8:\n\t\tif node.Value > math.MaxInt8 || node.Value < math.MinInt8 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows int8\", node.Value))\n\t\t}\n\t\tc.emitPush(int8(node.Value))\n\tcase reflect.Int16:\n\t\tif node.Value > math.MaxInt16 || node.Value < math.MinInt16 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows int16\", node.Value))\n\t\t}\n\t\tc.emitPush(int16(node.Value))\n\tcase reflect.Int32:\n\t\tif node.Value > math.MaxInt32 || node.Value < math.MinInt32 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows int32\", node.Value))\n\t\t}\n\t\tc.emitPush(int32(node.Value))\n\tcase reflect.Int64:\n\t\tc.emitPush(int64(node.Value))\n\tcase reflect.Uint:\n\t\tif node.Value < 0 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows uint\", node.Value))\n\t\t}\n\t\tc.emitPush(uint(node.Value))\n\tcase reflect.Uint8:\n\t\tif node.Value > math.MaxUint8 || node.Value < 0 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows uint8\", node.Value))\n\t\t}\n\t\tc.emitPush(uint8(node.Value))\n\tcase reflect.Uint16:\n\t\tif node.Value > math.MaxUint16 || node.Value < 0 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows uint16\", node.Value))\n\t\t}\n\t\tc.emitPush(uint16(node.Value))\n\tcase reflect.Uint32:\n\t\tif node.Value < 0 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows uint32\", node.Value))\n\t\t}\n\t\tc.emitPush(uint32(node.Value))\n\tcase reflect.Uint64:\n\t\tif node.Value < 0 {\n\t\t\tpanic(fmt.Sprintf(\"constant %d overflows uint64\", node.Value))\n\t\t}\n\t\tc.emitPush(uint64(node.Value))\n\tdefault:\n\t\tc.emitPush(node.Value)\n\t}\n}\n\nfunc (c *compiler) FloatNode(node *ast.FloatNode) {\n\tswitch node.Type().Kind() {\n\tcase reflect.Float32:\n\t\tc.emitPush(float32(node.Value))\n\tcase reflect.Float64:\n\t\tc.emitPush(node.Value)\n\tdefault:\n\t\tc.emitPush(node.Value)\n\t}\n}\n\nfunc (c *compiler) BoolNode(node *ast.BoolNode) {\n\tif node.Value {\n\t\tc.emit(OpTrue)\n\t} else {\n\t\tc.emit(OpFalse)\n\t}\n}\n\nfunc (c *compiler) StringNode(node *ast.StringNode) {\n\tc.emitPush(node.Value)\n}\n\nfunc (c *compiler) BytesNode(node *ast.BytesNode) {\n\tc.emitPush(node.Value)\n}\n\nfunc (c *compiler) ConstantNode(node *ast.ConstantNode) {\n\tif node.Value == nil {\n\t\tc.emit(OpNil)\n\t\treturn\n\t}\n\tc.emitPush(node.Value)\n}\n\nfunc (c *compiler) UnaryNode(node *ast.UnaryNode) {\n\tc.compile(node.Node)\n\tc.derefInNeeded(node.Node)\n\n\tswitch node.Operator {\n\n\tcase \"!\", \"not\":\n\t\tc.emit(OpNot)\n\n\tcase \"+\":\n\t\t// Do nothing\n\n\tcase \"-\":\n\t\tc.emit(OpNegate)\n\n\tdefault:\n\t\tpanic(fmt.Sprintf(\"unknown operator (%v)\", node.Operator))\n\t}\n}\n\nfunc (c *compiler) BinaryNode(node *ast.BinaryNode) {\n\tswitch node.Operator {\n\tcase \"==\":\n\t\tc.equalBinaryNode(node)\n\n\tcase \"!=\":\n\t\tc.equalBinaryNode(node)\n\t\tc.emit(OpNot)\n\n\tcase \"or\", \"||\":\n\t\tif c.config != nil && !c.config.ShortCircuit {\n\t\t\tc.compile(node.Left)\n\t\t\tc.derefInNeeded(node.Left)\n\t\t\tc.compile(node.Right)\n\t\t\tc.derefInNeeded(node.Right)\n\t\t\tc.emit(OpOr)\n\t\t\tbreak\n\t\t}\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tend := c.emit(OpJumpIfTrue, placeholder)\n\t\tc.emit(OpPop)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.patchJump(end)\n\n\tcase \"and\", \"&&\":\n\t\tif c.config != nil && !c.config.ShortCircuit {\n\t\t\tc.compile(node.Left)\n\t\t\tc.derefInNeeded(node.Left)\n\t\t\tc.compile(node.Right)\n\t\t\tc.derefInNeeded(node.Right)\n\t\t\tc.emit(OpAnd)\n\t\t\tbreak\n\t\t}\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tend := c.emit(OpJumpIfFalse, placeholder)\n\t\tc.emit(OpPop)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.patchJump(end)\n\n\tcase \"<\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpLess)\n\n\tcase \">\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpMore)\n\n\tcase \"<=\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpLessOrEqual)\n\n\tcase \">=\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpMoreOrEqual)\n\n\tcase \"+\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpAdd)\n\n\tcase \"-\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpSubtract)\n\n\tcase \"*\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpMultiply)\n\n\tcase \"/\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpDivide)\n\n\tcase \"%\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpModulo)\n\n\tcase \"**\", \"^\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpExponent)\n\n\tcase \"in\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpIn)\n\n\tcase \"matches\":\n\t\tif str, ok := node.Right.(*ast.StringNode); ok {\n\t\t\tre, err := regexp.Compile(str.Value)\n\t\t\tif err != nil {\n\t\t\t\tpanic(err)\n\t\t\t}\n\t\t\tc.compile(node.Left)\n\t\t\tc.derefInNeeded(node.Left)\n\t\t\tc.emit(OpMatchesConst, c.addConstant(re))\n\t\t} else {\n\t\t\tc.compile(node.Left)\n\t\t\tc.derefInNeeded(node.Left)\n\t\t\tc.compile(node.Right)\n\t\t\tc.derefInNeeded(node.Right)\n\t\t\tc.emit(OpMatches)\n\t\t}\n\n\tcase \"contains\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpContains)\n\n\tcase \"startsWith\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpStartsWith)\n\n\tcase \"endsWith\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpEndsWith)\n\n\tcase \"..\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.emit(OpRange)\n\n\tcase \"??\":\n\t\tc.compile(node.Left)\n\t\tc.derefInNeeded(node.Left)\n\t\tend := c.emit(OpJumpIfNotNil, placeholder)\n\t\tc.emit(OpPop)\n\t\tc.compile(node.Right)\n\t\tc.derefInNeeded(node.Right)\n\t\tc.patchJump(end)\n\n\tdefault:\n\t\tpanic(fmt.Sprintf(\"unknown operator (%v)\", node.Operator))\n\n\t}\n}\n\nfunc (c *compiler) equalBinaryNode(node *ast.BinaryNode) {\n\tl := kind(node.Left.Type())\n\tr := kind(node.Right.Type())\n\n\tleftIsSimple := isSimpleType(node.Left)\n\trightIsSimple := isSimpleType(node.Right)\n\tleftAndRightAreSimple := leftIsSimple && rightIsSimple\n\n\tc.compile(node.Left)\n\tc.derefInNeeded(node.Left)\n\tc.compile(node.Right)\n\tc.derefInNeeded(node.Right)\n\n\tif l == r && l == reflect.Int && leftAndRightAreSimple {\n\t\tc.emit(OpEqualInt)\n\t} else if l == r && l == reflect.String && leftAndRightAreSimple {\n\t\tc.emit(OpEqualString)\n\t} else {\n\t\tc.emit(OpEqual)\n\t}\n}\n\nfunc isSimpleType(node ast.Node) bool {\n\tif node == nil {\n\t\treturn false\n\t}\n\tt := node.Type()\n\tif t == nil {\n\t\treturn false\n\t}\n\treturn t.PkgPath() == \"\"\n}\n\nfunc (c *compiler) ChainNode(node *ast.ChainNode) {\n\tc.chains = append(c.chains, []int{})\n\tc.compile(node.Node)\n\tfor _, ph := range c.chains[len(c.chains)-1] {\n\t\tc.patchJump(ph) // If chain activated jump here (got nit somewhere).\n\t}\n\tparent := c.nodeParent()\n\tif binary, ok := parent.(*ast.BinaryNode); ok && binary.Operator == \"??\" {\n\t\t// If chain is used in nil coalescing operator, we can omit\n\t\t// nil push at the end of the chain. The ?? operator will\n\t\t// handle it.\n\t} else {\n\t\t// We need to put the nil on the stack, otherwise \"typed\"\n\t\t// nil will be used as a result of the chain.\n\t\tj := c.emit(OpJumpIfNotNil, placeholder)\n\t\tc.emit(OpPop)\n\t\tc.emit(OpNil)\n\t\tc.patchJump(j)\n\t}\n\tc.chains = c.chains[:len(c.chains)-1]\n}\n\nfunc (c *compiler) MemberNode(node *ast.MemberNode) {\n\tvar env Nature\n\tif c.config != nil {\n\t\tenv = c.config.Env\n\t}\n\n\tif ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok {\n\t\tc.compile(node.Node)\n\t\tc.emit(OpMethod, c.addConstant(&runtime.Method{\n\t\t\tName: name,\n\t\t\tIndex: index,\n\t\t}))\n\t\treturn\n\t}\n\top := OpFetch\n\tbase := node.Node\n\n\tok, index, nodeName := checker.FieldIndex(c.ntCache, env, node)\n\tpath := []string{nodeName}\n\n\tif ok {\n\t\top = OpFetchField\n\t\tfor !node.Optional {\n\t\t\tif ident, isIdent := base.(*ast.IdentifierNode); isIdent {\n\t\t\t\tif ok, identIndex, name := checker.FieldIndex(c.ntCache, env, ident); ok {\n\t\t\t\t\tindex = append(identIndex, index...)\n\t\t\t\t\tpath = append([]string{name}, path...)\n\t\t\t\t\tc.emitLocation(ident.Location(), OpLoadField, c.addConstant(\n\t\t\t\t\t\t&runtime.Field{Index: index, Path: path},\n\t\t\t\t\t))\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif member, isMember := base.(*ast.MemberNode); isMember {\n\t\t\t\tif ok, memberIndex, name := checker.FieldIndex(c.ntCache, env, member); ok {\n\t\t\t\t\tindex = append(memberIndex, index...)\n\t\t\t\t\tpath = append([]string{name}, path...)\n\t\t\t\t\tnode = member\n\t\t\t\t\tbase = member.Node\n\t\t\t\t} else {\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\n\tc.compile(base)\n\t// If the field is optional, we need to jump over the fetch operation.\n\t// If no ChainNode (none c.chains) is used, do not compile the optional fetch.\n\tif node.Optional && len(c.chains) > 0 {\n\t\tph := c.emit(OpJumpIfNil, placeholder)\n\t\tc.chains[len(c.chains)-1] = append(c.chains[len(c.chains)-1], ph)\n\t}\n\n\tif op == OpFetch {\n\t\tc.compile(node.Property)\n\t\tderef := true\n\t\t// If the map key is a pointer, we should not dereference the property.\n\t\tif node.Node.Type() != nil && node.Node.Type().Kind() == reflect.Map {\n\t\t\tkeyType := node.Node.Type().Key()\n\t\t\tpropType := node.Property.Type()\n\t\t\tif propType != nil && propType.AssignableTo(keyType) {\n\t\t\t\tderef = false\n\t\t\t}\n\t\t}\n\t\tif deref {\n\t\t\tc.derefInNeeded(node.Property)\n\t\t}\n\t\tc.emit(OpFetch)\n\t} else {\n\t\tc.emitLocation(node.Location(), op, c.addConstant(\n\t\t\t&runtime.Field{Index: index, Path: path},\n\t\t))\n\t}\n}\n\nfunc (c *compiler) SliceNode(node *ast.SliceNode) {\n\tc.compile(node.Node)\n\tif node.To != nil {\n\t\tc.compile(node.To)\n\t\tc.derefInNeeded(node.To)\n\t} else {\n\t\tc.emit(OpLen)\n\t}\n\tif node.From != nil {\n\t\tc.compile(node.From)\n\t\tc.derefInNeeded(node.From)\n\t} else {\n\t\tc.emitPush(0)\n\t}\n\tc.emit(OpSlice)\n}\n\nfunc (c *compiler) CallNode(node *ast.CallNode) {\n\tfn := node.Callee.Type()\n\tif fn.Kind() == reflect.Func {\n\t\tfnInOffset := 0\n\t\tfnNumIn := fn.NumIn()\n\t\tswitch callee := node.Callee.(type) {\n\t\tcase *ast.MemberNode:\n\t\t\tif prop, ok := callee.Property.(*ast.StringNode); ok {\n\t\t\t\tif _, ok = callee.Node.Type().MethodByName(prop.Value); ok && callee.Node.Type().Kind() != reflect.Interface {\n\t\t\t\t\tfnInOffset = 1\n\t\t\t\t\tfnNumIn--\n\t\t\t\t}\n\t\t\t}\n\t\tcase *ast.IdentifierNode:\n\t\t\tif t, ok := c.config.Env.MethodByName(c.ntCache, callee.Value); ok && t.Method {\n\t\t\t\tfnInOffset = 1\n\t\t\t\tfnNumIn--\n\t\t\t}\n\t\t}\n\t\tfor i, arg := range node.Arguments {\n\t\t\tc.compile(arg)\n\n\t\t\tvar in reflect.Type\n\t\t\tif fn.IsVariadic() && i >= fnNumIn-1 {\n\t\t\t\tin = fn.In(fn.NumIn() - 1).Elem()\n\t\t\t} else {\n\t\t\t\tin = fn.In(i + fnInOffset)\n\t\t\t}\n\n\t\t\tc.derefParam(in, arg)\n\t\t}\n\t} else {\n\t\tfor _, arg := range node.Arguments {\n\t\t\tc.compile(arg)\n\t\t}\n\t}\n\n\tif ident, ok := node.Callee.(*ast.IdentifierNode); ok {\n\t\tif c.config != nil {\n\t\t\tif fn, ok := c.config.Functions[ident.Value]; ok {\n\t\t\t\tc.emitFunction(fn, len(node.Arguments))\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t}\n\tc.compile(node.Callee)\n\n\tif c.config != nil {\n\t\tisMethod, _, _ := checker.MethodIndex(c.ntCache, c.config.Env, node.Callee)\n\t\tif index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok {\n\t\t\tc.emit(OpCallTyped, index)\n\t\t\treturn\n\t\t} else if checker.IsFastFunc(node.Callee.Type(), isMethod) {\n\t\t\tc.emit(OpCallFast, len(node.Arguments))\n\t\t} else {\n\t\t\tc.emit(OpCall, len(node.Arguments))\n\t\t}\n\t} else {\n\t\tc.emit(OpCall, len(node.Arguments))\n\t}\n}\n\nfunc (c *compiler) BuiltinNode(node *ast.BuiltinNode) {\n\tswitch node.Name {\n\tcase \"all\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tloopBreak = c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tc.emit(OpTrue)\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"none\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emit(OpNot)\n\t\t\tloopBreak = c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tc.emit(OpTrue)\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"any\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tloopBreak = c.emit(OpJumpIfTrue, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tc.emit(OpFalse)\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"one\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emitCond(func() {\n\t\t\t\tc.emit(OpIncrementCount)\n\t\t\t})\n\t\t})\n\t\tc.emit(OpGetCount)\n\t\tc.emitPush(1)\n\t\tc.emit(OpEqual)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"filter\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emitCond(func() {\n\t\t\t\tc.emit(OpIncrementCount)\n\t\t\t\tif node.Map != nil {\n\t\t\t\t\tc.compile(node.Map)\n\t\t\t\t} else {\n\t\t\t\t\tc.emit(OpPointer)\n\t\t\t\t}\n\t\t\t})\n\t\t})\n\t\tc.emit(OpGetCount)\n\t\tc.emit(OpEnd)\n\t\tc.emit(OpArray)\n\t\treturn\n\n\tcase \"map\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t})\n\t\tc.emit(OpGetLen)\n\t\tc.emit(OpEnd)\n\t\tc.emit(OpArray)\n\t\treturn\n\n\tcase \"count\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tif len(node.Arguments) == 2 {\n\t\t\t\tc.compile(node.Arguments[1])\n\t\t\t} else {\n\t\t\t\tc.emit(OpPointer)\n\t\t\t}\n\t\t\tc.emitCond(func() {\n\t\t\t\tc.emit(OpIncrementCount)\n\t\t\t\t// Early termination if threshold is set\n\t\t\t\tif node.Threshold != nil {\n\t\t\t\t\tc.emit(OpGetCount)\n\t\t\t\t\tc.emit(OpInt, *node.Threshold)\n\t\t\t\t\tc.emit(OpMoreOrEqual)\n\t\t\t\t\tloopBreak = c.emit(OpJumpIfTrue, placeholder)\n\t\t\t\t\tc.emit(OpPop)\n\t\t\t\t}\n\t\t\t})\n\t\t})\n\t\tc.emit(OpGetCount)\n\t\tif node.Threshold != nil {\n\t\t\tend := c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(loopBreak)\n\t\t\t// Early exit path: pop the bool comparison result, push count\n\t\t\tc.emit(OpPop)\n\t\t\tc.emit(OpGetCount)\n\t\t\tc.patchJump(end)\n\t\t}\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"sum\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tc.emit(OpInt, 0)\n\t\tc.emit(OpSetAcc)\n\t\tc.emitLoop(func() {\n\t\t\tif len(node.Arguments) == 2 {\n\t\t\t\tc.compile(node.Arguments[1])\n\t\t\t} else {\n\t\t\t\tc.emit(OpPointer)\n\t\t\t}\n\t\t\tc.emit(OpGetAcc)\n\t\t\tc.emit(OpAdd)\n\t\t\tc.emit(OpSetAcc)\n\t\t})\n\t\tc.emit(OpGetAcc)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"find\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tnoop := c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t\tif node.Map != nil {\n\t\t\t\tc.compile(node.Map)\n\t\t\t} else {\n\t\t\t\tc.emit(OpPointer)\n\t\t\t}\n\t\t\tloopBreak = c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(noop)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tif node.Throws {\n\t\t\tc.emit(OpPush, c.addConstant(fmt.Errorf(\"reflect: slice index out of range\")))\n\t\t\tc.emit(OpThrow)\n\t\t} else {\n\t\t\tc.emit(OpNil)\n\t\t}\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"findIndex\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tnoop := c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t\tc.emit(OpGetIndex)\n\t\t\tloopBreak = c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(noop)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tc.emit(OpNil)\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"findLast\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoopBackwards(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tnoop := c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t\tif node.Map != nil {\n\t\t\t\tc.compile(node.Map)\n\t\t\t} else {\n\t\t\t\tc.emit(OpPointer)\n\t\t\t}\n\t\t\tloopBreak = c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(noop)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tif node.Throws {\n\t\t\tc.emit(OpPush, c.addConstant(fmt.Errorf(\"reflect: slice index out of range\")))\n\t\t\tc.emit(OpThrow)\n\t\t} else {\n\t\t\tc.emit(OpNil)\n\t\t}\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"findLastIndex\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tvar loopBreak int\n\t\tc.emitLoopBackwards(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tnoop := c.emit(OpJumpIfFalse, placeholder)\n\t\t\tc.emit(OpPop)\n\t\t\tc.emit(OpGetIndex)\n\t\t\tloopBreak = c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(noop)\n\t\t\tc.emit(OpPop)\n\t\t})\n\t\tc.emit(OpNil)\n\t\tc.patchJump(loopBreak)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"groupBy\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tc.emit(OpCreate, 1)\n\t\tc.emit(OpSetAcc)\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emit(OpGroupBy)\n\t\t})\n\t\tc.emit(OpGetAcc)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"sortBy\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tif len(node.Arguments) == 3 {\n\t\t\tc.compile(node.Arguments[2])\n\t\t} else {\n\t\t\tc.emit(OpPush, c.addConstant(\"asc\"))\n\t\t}\n\t\tc.emit(OpCreate, 2)\n\t\tc.emit(OpSetAcc)\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emit(OpSortBy)\n\t\t})\n\t\tc.emit(OpSort)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\tcase \"reduce\":\n\t\tc.compile(node.Arguments[0])\n\t\tc.derefInNeeded(node.Arguments[0])\n\t\tc.emit(OpBegin)\n\t\tif len(node.Arguments) == 3 {\n\t\t\tc.compile(node.Arguments[2])\n\t\t\tc.derefInNeeded(node.Arguments[2])\n\t\t\tc.emit(OpSetAcc)\n\t\t} else {\n\t\t\t// When no initial value is provided, we use the first element as the\n\t\t\t// accumulator. But first we must check if the array is empty to avoid\n\t\t\t// an index out of range panic.\n\t\t\tempty := c.emit(OpJumpIfEnd, placeholder)\n\t\t\tc.emit(OpPointer)\n\t\t\tc.emit(OpIncrementIndex)\n\t\t\tc.emit(OpSetAcc)\n\t\t\tjumpPastError := c.emit(OpJump, placeholder)\n\t\t\tc.patchJump(empty)\n\t\t\tc.emit(OpPush, c.addConstant(fmt.Errorf(\"reduce of empty array with no initial value\")))\n\t\t\tc.emit(OpThrow)\n\t\t\tc.patchJump(jumpPastError)\n\t\t}\n\t\tc.emitLoop(func() {\n\t\t\tc.compile(node.Arguments[1])\n\t\t\tc.emit(OpSetAcc)\n\t\t})\n\t\tc.emit(OpGetAcc)\n\t\tc.emit(OpEnd)\n\t\treturn\n\n\t}\n\n\tif id, ok := builtin.Index[node.Name]; ok {\n\t\tf := builtin.Builtins[id]\n\t\tfor i, arg := range node.Arguments {\n\t\t\tc.compile(arg)\n\t\t\targType := arg.Type()\n\t\t\tif argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown(c.ntCache) {\n\t\t\t\tif f.Deref == nil {\n\t\t\t\t\t// By default, builtins expect arguments to be dereferenced.\n\t\t\t\t\tc.emit(OpDeref)\n\t\t\t\t} else {\n\t\t\t\t\tif f.Deref(i, argType) {\n\t\t\t\t\t\tc.emit(OpDeref)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif f.Fast != nil {\n\t\t\tc.emit(OpCallBuiltin1, id)\n\t\t} else if f.Safe != nil {\n\t\t\tid := c.addConstant(f.Safe)\n\t\t\tc.emit(OpPush, id)\n\t\t\tc.debugInfo[fmt.Sprintf(\"const_%d\", id)] = node.Name\n\t\t\tc.emit(OpCallSafe, len(node.Arguments))\n\t\t} else if f.Func != nil {\n\t\t\tc.emitFunction(f, len(node.Arguments))\n\t\t}\n\t\treturn\n\t}\n\n\tpanic(fmt.Sprintf(\"unknown builtin %v\", node.Name))\n}\n\nfunc (c *compiler) emitCond(body func()) {\n\tnoop := c.emit(OpJumpIfFalse, placeholder)\n\tc.emit(OpPop)\n\n\tbody()\n\n\tjmp := c.emit(OpJump, placeholder)\n\tc.patchJump(noop)\n\tc.emit(OpPop)\n\tc.patchJump(jmp)\n}\n\nfunc (c *compiler) emitLoop(body func()) {\n\tbegin := len(c.bytecode)\n\tend := c.emit(OpJumpIfEnd, placeholder)\n\n\tbody()\n\n\tc.emit(OpIncrementIndex)\n\tc.emit(OpJumpBackward, c.calcBackwardJump(begin))\n\tc.patchJump(end)\n}\n\nfunc (c *compiler) emitLoopBackwards(body func()) {\n\tc.emit(OpGetLen)\n\tc.emit(OpInt, 1)\n\tc.emit(OpSubtract)\n\tc.emit(OpSetIndex)\n\tbegin := len(c.bytecode)\n\tc.emit(OpGetIndex)\n\tc.emit(OpInt, 0)\n\tc.emit(OpMoreOrEqual)\n\tend := c.emit(OpJumpIfFalse, placeholder)\n\n\tbody()\n\n\tc.emit(OpDecrementIndex)\n\tc.emit(OpJumpBackward, c.calcBackwardJump(begin))\n\tc.patchJump(end)\n}\n\nfunc (c *compiler) PredicateNode(node *ast.PredicateNode) {\n\tc.compile(node.Node)\n}\n\nfunc (c *compiler) PointerNode(node *ast.PointerNode) {\n\tswitch node.Name {\n\tcase \"index\":\n\t\tc.emit(OpGetIndex)\n\tcase \"acc\":\n\t\tc.emit(OpGetAcc)\n\tcase \"\":\n\t\tc.emit(OpPointer)\n\tdefault:\n\t\tpanic(fmt.Sprintf(\"unknown pointer %v\", node.Name))\n\t}\n}\n\nfunc (c *compiler) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) {\n\tc.compile(node.Value)\n\tindex := c.addVariable(node.Name)\n\tc.emit(OpStore, index)\n\tc.beginScope(node.Name, index)\n\tc.compile(node.Expr)\n\tc.endScope()\n}\n\nfunc (c *compiler) SequenceNode(node *ast.SequenceNode) {\n\tfor i, n := range node.Nodes {\n\t\tc.compile(n)\n\t\tif i < len(node.Nodes)-1 {\n\t\t\tc.emit(OpPop)\n\t\t}\n\t}\n}\n\nfunc (c *compiler) beginScope(name string, index int) {\n\tc.scopes = append(c.scopes, scope{name, index})\n}\n\nfunc (c *compiler) endScope() {\n\tc.scopes = c.scopes[:len(c.scopes)-1]\n}\n\nfunc (c *compiler) lookupVariable(name string) (int, bool) {\n\tfor i := len(c.scopes) - 1; i >= 0; i-- {\n\t\tif c.scopes[i].variableName == name {\n\t\t\treturn c.scopes[i].index, true\n\t\t}\n\t}\n\treturn 0, false\n}\n\nfunc (c *compiler) ConditionalNode(node *ast.ConditionalNode) {\n\tc.compile(node.Cond)\n\tc.derefInNeeded(node.Cond)\n\totherwise := c.emit(OpJumpIfFalse, placeholder)\n\n\tc.emit(OpPop)\n\tc.compile(node.Exp1)\n\tend := c.emit(OpJump, placeholder)\n\n\tc.patchJump(otherwise)\n\tc.emit(OpPop)\n\tc.compile(node.Exp2)\n\n\tc.patchJump(end)\n}\n\nfunc (c *compiler) ArrayNode(node *ast.ArrayNode) {\n\tfor _, node := range node.Nodes {\n\t\tc.compile(node)\n\t}\n\n\tc.emitPush(len(node.Nodes))\n\tc.emit(OpArray)\n}\n\nfunc (c *compiler) MapNode(node *ast.MapNode) {\n\tfor _, pair := range node.Pairs {\n\t\tc.compile(pair)\n\t}\n\n\tc.emitPush(len(node.Pairs))\n\tc.emit(OpMap)\n}\n\nfunc (c *compiler) PairNode(node *ast.PairNode) {\n\tc.compile(node.Key)\n\tc.compile(node.Value)\n}\n\nfunc (c *compiler) derefInNeeded(node ast.Node) {\n\tif node.Nature().Nil {\n\t\treturn\n\t}\n\tswitch node.Type().Kind() {\n\tcase reflect.Ptr, reflect.Interface:\n\t\tc.emit(OpDeref)\n\t}\n}\n\nfunc (c *compiler) derefParam(in reflect.Type, param ast.Node) {\n\tif param.Nature().Nil {\n\t\treturn\n\t}\n\tif param.Type().AssignableTo(in) {\n\t\treturn\n\t}\n\tif in.Kind() != reflect.Ptr && param.Type().Kind() == reflect.Ptr {\n\t\tc.emit(OpDeref)\n\t}\n}\n\nfunc (c *compiler) optimize() {\n\tfor i, op := range c.bytecode {\n\t\tswitch op {\n\t\tcase OpJumpIfTrue, OpJumpIfFalse, OpJumpIfNil, OpJumpIfNotNil:\n\t\t\ttarget := i + c.arguments[i] + 1\n\t\t\tfor target < len(c.bytecode) && c.bytecode[target] == op {\n\t\t\t\ttarget += c.arguments[target] + 1\n\t\t\t}\n\t\t\tc.arguments[i] = target - i - 1\n\t\t}\n\t}\n}\n\nfunc kind(t reflect.Type) reflect.Kind {\n\tif t == nil {\n\t\treturn reflect.Invalid\n\t}\n\treturn t.Kind()\n}\n"
},
{
"path": "compiler/compiler_test.go",
"content": "package compiler_test\n\nimport (\n\t\"math\"\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/expr-lang/expr/internal/testify/assert\"\n\t\"github.com/expr-lang/expr/internal/testify/require\"\n\n\t\"github.com/expr-lang/expr\"\n\t\"github.com/expr-lang/expr/test/mock\"\n\t\"github.com/expr-lang/expr/test/playground\"\n\t\"github.com/expr-lang/expr/vm\"\n\t\"github.com/expr-lang/expr/vm/runtime\"\n)\n\ntype B struct {\n\t_ byte\n\t_ byte\n\tC struct {\n\t\t_ byte\n\t\t_ byte\n\t\t_ byte\n\t\tD int\n\t}\n}\n\nfunc (B) FuncInB() int {\n\treturn 0\n}\n\ntype Env struct {\n\tA struct {\n\t\t_ byte\n\t\tB B\n\t\tMap map[string]B\n\t\tPtr *int\n\t}\n}\n\n// AFunc is a method what goes before Func in the alphabet.\nfunc (e Env) AFunc() int {\n\treturn 0\n}\n\nfunc (e Env) Func() B {\n\treturn B{}\n}\n\nfunc TestCompile(t *testing.T) {\n\tvar tests = []struct {\n\t\tcode string\n\t\twant vm.Program\n\t}{\n\t\t{\n\t\t\t`65535`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\tmath.MaxUint16,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`.5`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t.5,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`true`,\n\t\t\tvm.Program{\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`\"string\"`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t\"string\",\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`\"string\" == \"string\"`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t\"string\",\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpEqualString,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`1000000 == 1000000`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\tint64(1000000),\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpEqualInt,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`-1`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{1},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpNegate,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`true && true || true`,\n\t\t\tvm.Program{\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t\tvm.OpJumpIfFalse,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t\tvm.OpJumpIfTrue,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 2, 0, 0, 2, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`true && (true || true)`,\n\t\t\tvm.Program{\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t\tvm.OpJumpIfFalse,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t\tvm.OpJumpIfTrue,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpTrue,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 5, 0, 0, 2, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A.B.C.D`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0, 1, 2, 3},\n\t\t\t\t\t\tPath: []string{\"A\", \"B\", \"C\", \"D\"},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A?.B.C.D`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0},\n\t\t\t\t\t\tPath: []string{\"A\"},\n\t\t\t\t\t},\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{1, 2, 3},\n\t\t\t\t\t\tPath: []string{\"B\", \"C\", \"D\"},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpJumpIfNil,\n\t\t\t\t\tvm.OpFetchField,\n\t\t\t\t\tvm.OpJumpIfNotNil,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpNil,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 1, 1, 2, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A.B?.C.D`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0, 1},\n\t\t\t\t\t\tPath: []string{\"A\", \"B\"},\n\t\t\t\t\t},\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{2, 3},\n\t\t\t\t\t\tPath: []string{\"C\", \"D\"},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpJumpIfNil,\n\t\t\t\t\tvm.OpFetchField,\n\t\t\t\t\tvm.OpJumpIfNotNil,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpNil,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 1, 1, 2, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A?.B`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0},\n\t\t\t\t\t\tPath: []string{\"A\"},\n\t\t\t\t\t},\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{1},\n\t\t\t\t\t\tPath: []string{\"B\"},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpJumpIfNil,\n\t\t\t\t\tvm.OpFetchField,\n\t\t\t\t\tvm.OpJumpIfNotNil,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpNil,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 1, 1, 2, 0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A?.B ?? 42`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0},\n\t\t\t\t\t\tPath: []string{\"A\"},\n\t\t\t\t\t},\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{1},\n\t\t\t\t\t\tPath: []string{\"B\"},\n\t\t\t\t\t},\n\t\t\t\t\t42,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpJumpIfNil,\n\t\t\t\t\tvm.OpFetchField,\n\t\t\t\t\tvm.OpJumpIfNotNil,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 1, 1, 2, 0, 2},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A.Map[\"B\"].C.D`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0, 2},\n\t\t\t\t\t\tPath: []string{\"A\", \"Map\"},\n\t\t\t\t\t},\n\t\t\t\t\t\"B\",\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{2, 3},\n\t\t\t\t\t\tPath: []string{\"C\", \"D\"},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpFetch,\n\t\t\t\t\tvm.OpFetchField,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 1, 0, 2},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A ?? 1`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0},\n\t\t\t\t\t\tPath: []string{\"A\"},\n\t\t\t\t\t},\n\t\t\t\t\t1,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpJumpIfNotNil,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 2, 0, 1},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`A.Ptr + 1`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Field{\n\t\t\t\t\t\tIndex: []int{0, 3},\n\t\t\t\t\t\tPath: []string{\"A\", \"Ptr\"},\n\t\t\t\t\t},\n\t\t\t\t\t1,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadField,\n\t\t\t\t\tvm.OpDeref,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpAdd,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0, 1, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`Func()`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Method{\n\t\t\t\t\t\tIndex: 1,\n\t\t\t\t\t\tName: \"Func\",\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadMethod,\n\t\t\t\t\tvm.OpCall,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`Func().FuncInB()`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t&runtime.Method{\n\t\t\t\t\t\tIndex: 1,\n\t\t\t\t\t\tName: \"Func\",\n\t\t\t\t\t},\n\t\t\t\t\t&runtime.Method{\n\t\t\t\t\t\tIndex: 0,\n\t\t\t\t\t\tName: \"FuncInB\",\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpLoadMethod,\n\t\t\t\t\tvm.OpCall,\n\t\t\t\t\tvm.OpMethod,\n\t\t\t\t\tvm.OpCallTyped,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0, 1, 12},\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\t`1; 2; 3`,\n\t\t\tvm.Program{\n\t\t\t\tConstants: []any{\n\t\t\t\t\t1,\n\t\t\t\t\t2,\n\t\t\t\t\t3,\n\t\t\t\t},\n\t\t\t\tBytecode: []vm.Opcode{\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t\tvm.OpPop,\n\t\t\t\t\tvm.OpPush,\n\t\t\t\t},\n\t\t\t\tArguments: []int{0, 0, 1, 0, 2},\n\t\t\t},\n\t\t},\n\t}\n\n\tfor _, test := range tests {\n\t\tt.Run(test.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(test.code, expr.Env(Env{}), expr.Optimize(false))\n\t\t\trequire.NoError(t, err)\n\n\t\t\tassert.Equal(t, test.want.Disassemble(), program.Disassemble())\n\t\t})\n\t}\n}\n\nfunc TestCompile_panic(t *testing.T) {\n\ttests := []string{\n\t\t`(TotalPosts.Profile[Authors > TotalPosts == get(nil, TotalLikes)] > Authors) ^ (TotalLikes / (Posts?.PublishDate[TotalPosts] < Posts))`,\n\t\t`one(Posts, nil)`,\n\t\t`trim(TotalViews, Posts) <= get(Authors, nil)`,\n\t\t`Authors.IsZero(nil * Authors) - (TotalViews && Posts ? nil : nil)[TotalViews.IsZero(false, \" \").IsZero(Authors)]`,\n\t}\n\tfor _, test := range tests {\n\t\tt.Run(test, func(t *testing.T) {\n\t\t\t_, err := expr.Compile(test, expr.Env(playground.Blog{}))\n\t\t\trequire.Error(t, err)\n\t\t})\n\t}\n}\n\nfunc TestCompile_FuncTypes(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"fn\": func([]any, string) string {\n\t\t\treturn \"foo\"\n\t\t},\n\t}\n\tprogram, err := expr.Compile(\"fn([1, 2], 'bar')\", expr.Env(env))\n\trequire.NoError(t, err)\n\trequire.Equal(t, vm.OpCallTyped, program.Bytecode[3])\n\trequire.Equal(t, 32, program.Arguments[3])\n}\n\nfunc TestCompile_FuncTypes_with_Method(t *testing.T) {\n\tenv := mock.Env{}\n\tprogram, err := expr.Compile(\"FuncTyped('bar')\", expr.Env(env))\n\trequire.NoError(t, err)\n\trequire.Equal(t, vm.OpCallTyped, program.Bytecode[2])\n\trequire.Equal(t, 76, program.Arguments[2])\n}\n\nfunc TestCompile_FuncTypes_excludes_named_functions(t *testing.T) {\n\tenv := mock.Env{}\n\tprogram, err := expr.Compile(\"FuncNamed('bar')\", expr.Env(env))\n\trequire.NoError(t, err)\n\trequire.Equal(t, vm.OpCall, program.Bytecode[2])\n\trequire.Equal(t, 1, program.Arguments[2])\n}\n\nfunc TestCompile_OpCallFast(t *testing.T) {\n\tenv := mock.Env{}\n\tprogram, err := expr.Compile(\"Fast(3, 2, 1)\", expr.Env(env))\n\trequire.NoError(t, err)\n\trequire.Equal(t, vm.OpCallFast, program.Bytecode[4])\n\trequire.Equal(t, 3, program.Arguments[4])\n}\n\nfunc TestCompile_optimizes_jumps(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"a\": true,\n\t\t\"b\": true,\n\t\t\"c\": true,\n\t\t\"d\": true,\n\t\t\"i64\": int64(1),\n\t}\n\ttests := []struct {\n\t\tcode string\n\t\twant string\n\t}{\n\t\t{\n\t\t\t`let foo = true; let bar = false; let baz = true; foo || bar || baz`,\n\t\t\t`0 OpTrue\n1 OpStore <0> foo\n2 OpFalse\n3 OpStore <1> bar\n4 OpTrue\n5 OpStore <2> baz\n6 OpLoadVar <0> foo\n7 OpJumpIfTrue <5> (13)\n8 OpPop\n9 OpLoadVar <1> bar\n10 OpJumpIfTrue <2> (13)\n11 OpPop\n12 OpLoadVar <2> baz\n`,\n\t\t},\n\t\t{\n\t\t\t`a && b && c`,\n\t\t\t`0 OpLoadFast <0> a\n1 OpJumpIfFalse <5> (7)\n2 OpPop\n3 OpLoadFast <1> b\n4 OpJumpIfFalse <2> (7)\n5 OpPop\n6 OpLoadFast <2> c\n`,\n\t\t},\n\t\t{\n\t\t\t`a && b || c && d`,\n\t\t\t`0 OpLoadFast <0> a\n1 OpJumpIfFalse <2> (4)\n2 OpPop\n3 OpLoadFast <1> b\n4 OpJumpIfTrue <5> (10)\n5 OpPop\n6 OpLoadFast <2> c\n7 OpJumpIfFalse <2> (10)\n8 OpPop\n9 OpLoadFast <3> d\n`,\n\t\t},\n\t\t{\n\t\t\t`filter([1, 2, 3, 4, 5], # > 3 && # != 4 && # != 5)`,\n\t\t\t`0 OpPush <0> [1 2 3 4 5]\n1 OpBegin\n2 OpJumpIfEnd <23> (26)\n3 OpPointer\n4 OpPush <1> 3\n5 OpMore\n6 OpJumpIfFalse <16> (23)\n7 OpPop\n8 OpPointer\n9 OpPush <2> 4\n10 OpEqualInt\n11 OpNot\n12 OpJumpIfFalse <10> (23)\n13 OpPop\n14 OpPointer\n15 OpPush <3> 5\n16 OpEqualInt\n17 OpNot\n18 OpJumpIfFalse <4> (23)\n19 OpPop\n20 OpIncrementCount\n21 OpPointer\n22 OpJump <1> (24)\n23 OpPop\n24 OpIncrementIndex\n25 OpJumpBackward <24> (2)\n26 OpGetCount\n27 OpEnd\n28 OpArray\n`,\n\t\t},\n\t\t{\n\t\t\t`let foo = true; let bar = false; let baz = true; foo && bar || baz`,\n\t\t\t`0 OpTrue\n1 OpStore <0> foo\n2 OpFalse\n3 OpStore <1> bar\n4 OpTrue\n5 OpStore <2> baz\n6 OpLoadVar <0> foo\n7 OpJumpIfFalse <2> (10)\n8 OpPop\n9 OpLoadVar <1> bar\n10 OpJumpIfTrue <2> (13)\n11 OpPop\n12 OpLoadVar <2> baz\n`,\n\t\t},\n\t\t{\n\t\t\t`true ?? nil ?? nil ?? nil`,\n\t\t\t`0 OpTrue\n1 OpJumpIfNotNil <8> (10)\n2 OpPop\n3 OpNil\n4 OpJumpIfNotNil <5> (10)\n5 OpPop\n6 OpNil\n7 OpJumpIfNotNil <2> (10)\n8 OpPop\n9 OpNil\n`,\n\t\t},\n\t\t{\n\t\t\t`let m = {\"a\": {\"b\": {\"c\": 1}}}; m?.a?.b?.c`,\n\t\t\t`0 OpPush <0> a\n1 OpPush <1> b\n2 OpPush <2> c\n3 OpPush <3> 1\n4 OpPush <3> 1\n5 OpMap\n6 OpPush <3> 1\n7 OpMap\n8 OpPush <3> 1\n9 OpMap\n10 OpStore <0> m\n11 OpLoadVar <0> m\n12 OpJumpIfNil <8> (21)\n13 OpPush <0> a\n14 OpFetch\n15 OpJumpIfNil <5> (21)\n16 OpPush <1> b\n17 OpFetch\n18 OpJumpIfNil <2> (21)\n19 OpPush <2> c\n20 OpFetch\n21 OpJumpIfNotNil <2> (24)\n22 OpPop\n23 OpNil\n`,\n\t\t},\n\t\t{\n\t\t\t`-1 not in [1, 2, 5]`,\n\t\t\t`0 OpPush <0> -1\n1 OpPush <1> map[1:{} 2:{} 5:{}]\n2 OpIn\n3 OpNot\n`,\n\t\t},\n\t\t{\n\t\t\t`1 + 8 not in [1, 2, 5]`,\n\t\t\t`0 OpPush <0> 9\n1 OpPush <1> map[1:{} 2:{} 5:{}]\n2 OpIn\n3 OpNot\n`,\n\t\t},\n\t\t{\n\t\t\t`true ? false : 8 not in [1, 2, 5]`,\n\t\t\t`0 OpTrue\n1 OpJumpIfFalse <3> (5)\n2 OpPop\n3 OpFalse\n4 OpJump <5> (10)\n5 OpPop\n6 OpPush <0> 8\n7 OpPush <1> map[1:{} 2:{} 5:{}]\n8 OpIn\n9 OpNot\n`,\n\t\t},\n\t}\n\n\tfor _, test := range tests {\n\t\tt.Run(test.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(test.code, expr.Env(env))\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, test.want, program.Disassemble())\n\t\t})\n\t}\n}\n\nfunc TestCompile_IntegerArgsFunc(t *testing.T) {\n\tenv := mock.Env{}\n\ttests := []struct{ code string }{\n\t\t{\"FuncInt(0)\"},\n\t\t{\"FuncInt8(0)\"},\n\t\t{\"FuncInt16(0)\"},\n\t\t{\"FuncInt32(0)\"},\n\t\t{\"FuncInt64(0)\"},\n\t\t{\"FuncUint(0)\"},\n\t\t{\"FuncUint8(0)\"},\n\t\t{\"FuncUint16(0)\"},\n\t\t{\"FuncUint32(0)\"},\n\t\t{\"FuncUint64(0)\"},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\t_, err := expr.Compile(tt.code, expr.Env(env))\n\t\t\trequire.NoError(t, err)\n\t\t})\n\t}\n}\n\nfunc TestCompile_call_on_nil(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": nil,\n\t}\n\t_, err := expr.Compile(`foo()`, expr.Env(env))\n\trequire.Error(t, err)\n\trequire.Contains(t, err.Error(), \"foo is nil; cannot call nil as function\")\n}\n\nfunc TestCompile_Expect(t *testing.T) {\n\ttests := []struct {\n\t\tinput string\n\t\toption expr.Option\n\t\top vm.Opcode\n\t\targ int\n\t}{\n\t\t{\n\t\t\tinput: \"1\",\n\t\t\toption: expr.AsKind(reflect.Int),\n\t\t\top: vm.OpCast,\n\t\t\targ: 0,\n\t\t},\n\t\t{\n\t\t\tinput: \"1\",\n\t\t\toption: expr.AsInt64(),\n\t\t\top: vm.OpCast,\n\t\t\targ: 1,\n\t\t},\n\t\t{\n\t\t\tinput: \"1\",\n\t\t\toption: expr.AsFloat64(),\n\t\t\top: vm.OpCast,\n\t\t\targ: 2,\n\t\t},\n\t\t{\n\t\t\tinput: \"true\",\n\t\t\toption: expr.AsBool(),\n\t\t\top: vm.OpCast,\n\t\t\targ: 3,\n\t\t},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.input, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.input, tt.option)\n\t\t\trequire.NoError(t, err)\n\n\t\t\tlastOp := program.Bytecode[len(program.Bytecode)-1]\n\t\t\tlastArg := program.Arguments[len(program.Arguments)-1]\n\n\t\t\tassert.Equal(t, tt.op, lastOp)\n\t\t\tassert.Equal(t, tt.arg, lastArg)\n\t\t})\n\t}\n}\n"
},
{
"path": "conf/config.go",
"content": "package conf\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\n\t\"github.com/expr-lang/expr/ast\"\n\t\"github.com/expr-lang/expr/builtin\"\n\t\"github.com/expr-lang/expr/checker/nature\"\n\t\"github.com/expr-lang/expr/vm/runtime\"\n)\n\nvar (\n\t// DefaultMemoryBudget represents default maximum allowed memory usage by the vm.VM.\n\tDefaultMemoryBudget uint = 1e6\n\n\t// DefaultMaxNodes represents default maximum allowed AST nodes by the compiler.\n\tDefaultMaxNodes uint = 1e4\n)\n\ntype FunctionsTable map[string]*builtin.Function\n\ntype Config struct {\n\tEnvObject any\n\tEnv nature.Nature\n\tExpect reflect.Kind\n\tExpectAny bool\n\tOptimize bool\n\tStrict bool\n\tShortCircuit bool\n\tProfile bool\n\tMaxNodes uint\n\tConstFns map[string]reflect.Value\n\tVisitors []ast.Visitor\n\tFunctions FunctionsTable\n\tBuiltins FunctionsTable\n\tDisabled map[string]bool // disabled builtins\n\tNtCache nature.Cache\n\t// DisableIfOperator disables the built-in `if ... { } else { }` operator syntax\n\t// so that users can use a custom function named `if(...)` without conflicts.\n\t// When enabled, the lexer treats `if`/`else` as identifiers and the parser\n\t// will not parse `if` statements.\n\tDisableIfOperator bool\n}\n\n// CreateNew creates new config with default values.\nfunc CreateNew() *Config {\n\tc := &Config{\n\t\tOptimize: true,\n\t\tShortCircuit: true,\n\t\tMaxNodes: DefaultMaxNodes,\n\t\tConstFns: make(map[string]reflect.Value),\n\t\tFunctions: make(map[string]*builtin.Function),\n\t\tBuiltins: make(map[string]*builtin.Function),\n\t\tDisabled: make(map[string]bool),\n\t}\n\tfor _, f := range builtin.Builtins {\n\t\tc.Builtins[f.Name] = f\n\t}\n\treturn c\n}\n\n// New creates new config with environment.\nfunc New(env any) *Config {\n\tc := CreateNew()\n\tc.WithEnv(env)\n\treturn c\n}\n\nfunc (c *Config) WithEnv(env any) {\n\tc.EnvObject = env\n\tc.Env = EnvWithCache(&c.NtCache, env)\n\tc.Strict = c.Env.Strict\n}\n\nfunc (c *Config) ConstExpr(name string) {\n\tif c.EnvObject == nil {\n\t\tpanic(\"no environment is specified for ConstExpr()\")\n\t}\n\tfn := reflect.ValueOf(runtime.Fetch(c.EnvObject, name))\n\tif fn.Kind() != reflect.Func {\n\t\tpanic(fmt.Errorf(\"const expression %q must be a function\", name))\n\t}\n\tc.ConstFns[name] = fn\n}\n\ntype Checker interface {\n\tCheck()\n}\n\nfunc (c *Config) Check() {\n\tfor _, v := range c.Visitors {\n\t\tif c, ok := v.(Checker); ok {\n\t\t\tc.Check()\n\t\t}\n\t}\n}\n\nfunc (c *Config) IsOverridden(name string) bool {\n\tif _, ok := c.Functions[name]; ok {\n\t\treturn true\n\t}\n\tif _, ok := c.Env.Get(&c.NtCache, name); ok {\n\t\treturn true\n\t}\n\treturn false\n}\n"
},
{
"path": "conf/env.go",
"content": "package conf\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\n\t. \"github.com/expr-lang/expr/checker/nature\"\n\t\"github.com/expr-lang/expr/internal/deref\"\n\t\"github.com/expr-lang/expr/types\"\n)\n\n// Env returns the Nature of the given environment.\n//\n// Deprecated: use EnvWithCache instead.\nfunc Env(env any) Nature {\n\treturn EnvWithCache(new(Cache), env)\n}\n\nfunc EnvWithCache(c *Cache, env any) Nature {\n\tif env == nil {\n\t\tn := c.NatureOf(map[string]any{})\n\t\tn.Strict = true\n\t\treturn n\n\t}\n\n\tswitch env := env.(type) {\n\tcase types.Map:\n\t\tnt := env.Nature()\n\t\treturn nt\n\t}\n\n\tv := reflect.ValueOf(env)\n\tt := v.Type()\n\n\tswitch deref.Value(v).Kind() {\n\tcase reflect.Struct:\n\t\tn := c.FromType(t)\n\t\tn.Strict = true\n\t\treturn n\n\n\tcase reflect.Map:\n\t\tn := c.FromType(v.Type())\n\t\tif n.TypeData == nil {\n\t\t\tn.TypeData = new(TypeData)\n\t\t}\n\t\tn.Strict = true\n\t\tn.Fields = make(map[string]Nature, v.Len())\n\n\t\tfor _, key := range v.MapKeys() {\n\t\t\telem := v.MapIndex(key)\n\t\t\tif !elem.IsValid() || !elem.CanInterface() {\n\t\t\t\tpanic(fmt.Sprintf(\"invalid map value: %s\", key))\n\t\t\t}\n\n\t\t\tface := elem.Interface()\n\n\t\t\tswitch face := face.(type) {\n\t\t\tcase types.Map:\n\t\t\t\tnt := face.Nature()\n\t\t\t\tn.Fields[key.String()] = nt\n\n\t\t\tdefault:\n\t\t\t\tif face == nil {\n\t\t\t\t\tn.Fields[key.String()] = c.NatureOf(nil)\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tn.Fields[key.String()] = c.NatureOf(face)\n\t\t\t}\n\n\t\t}\n\n\t\treturn n\n\t}\n\n\tpanic(fmt.Sprintf(\"unknown type %T\", env))\n}\n"
},
{
"path": "debug/debugger.go",
"content": "package debug\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/gdamore/tcell/v2\"\n\t\"github.com/rivo/tview\"\n\n\t. \"github.com/expr-lang/expr/vm\"\n)\n\nfunc StartDebugger(program *Program, env any) {\n\tvm := Debug()\n\tapp := tview.NewApplication()\n\ttable := tview.NewTable()\n\tstack := tview.NewTable()\n\tstack.\n\t\tSetBorder(true).\n\t\tSetTitle(\"Stack\")\n\tscope := tview.NewTable()\n\tscope.\n\t\tSetBorder(true).\n\t\tSetTitle(\"Scope\")\n\tsub := tview.NewFlex().\n\t\tSetDirection(tview.FlexRow).\n\t\tAddItem(stack, 0, 3, false).\n\t\tAddItem(scope, 0, 1, false)\n\tflex := tview.NewFlex().\n\t\tAddItem(table, 0, 1, true).\n\t\tAddItem(sub, 0, 1, false)\n\tapp.SetRoot(flex, true)\n\n\tdone := false\n\tgo func() {\n\t\tout, err := vm.Run(program, env)\n\t\tdone = true\n\t\tapp.QueueUpdateDraw(func() {\n\t\t\tsub.RemoveItem(stack)\n\t\t\tsub.RemoveItem(scope)\n\t\t\tresult := tview.NewTextView()\n\t\t\tresult.\n\t\t\t\tSetBorder(true).\n\t\t\t\tSetTitle(\"Output\")\n\t\t\tresult.SetText(fmt.Sprintf(\"%#v\", out))\n\t\t\tsub.AddItem(result, 0, 1, false)\n\t\t\tif err != nil {\n\t\t\t\terrorView := tview.NewTextView()\n\t\t\t\terrorView.\n\t\t\t\t\tSetBorder(true).\n\t\t\t\t\tSetTitle(\"Error\")\n\t\t\t\terrorView.SetText(err.Error())\n\t\t\t\tsub.AddItem(errorView, 0, 1, false)\n\t\t\t}\n\t\t})\n\t}()\n\n\tindex := make(map[int]int)\n\tvar buf strings.Builder\n\tprogram.DisassembleWriter(&buf)\n\n\tfor row, line := range strings.Split(buf.String(), \"\\n\") {\n\t\tif line == \"\" {\n\t\t\tcontinue\n\t\t}\n\t\tparts := strings.Split(line, \"\\t\")\n\n\t\tip, err := strconv.Atoi(parts[0])\n\t\tcheck(err)\n\t\tindex[ip] = row\n\t\ttable.SetCellSimple(row, 0, fmt.Sprintf(\"% *d\", 5, ip))\n\n\t\tfor col := 1; col < len(parts); col++ {\n\t\t\ttable.SetCellSimple(row, col, parts[col])\n\t\t}\n\t\tfor col := len(parts); col < 4; col++ {\n\t\t\ttable.SetCellSimple(row, col, \"\")\n\t\t}\n\t\ttable.SetCell(row, 4, tview.NewTableCell(\"\").SetExpansion(1))\n\t}\n\n\tdraw := func(ip int) {\n\t\tapp.QueueUpdateDraw(func() {\n\t\t\tfor row := 0; row < table.GetRowCount(); row++ {\n\t\t\t\tfor col := 0; col < table.GetColumnCount(); col++ {\n\t\t\t\t\ttable.GetCell(row, col).SetBackgroundColor(tcell.ColorBlack)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif row, ok := index[ip]; ok {\n\t\t\t\ttable.Select(row, 0)\n\t\t\t\tfor col := 0; col < 5; col++ {\n\t\t\t\t\ttable.GetCell(row, col).SetBackgroundColor(tcell.ColorMediumBlue)\n\t\t\t\t}\n\t\t\t\ttable.SetOffset(row-10, 0)\n\n\t\t\t\topcode := table.GetCell(row, 1).Text\n\t\t\t\tif strings.HasPrefix(opcode, \"OpJump\") {\n\t\t\t\t\tjump := table.GetCell(row, 3).Text\n\t\t\t\t\tjump = strings.Trim(jump, \"()\")\n\t\t\t\t\tip, err := strconv.Atoi(jump)\n\t\t\t\t\tif err == nil {\n\t\t\t\t\t\tif row, ok := index[ip]; ok {\n\t\t\t\t\t\t\tfor col := 0; col < 5; col++ {\n\t\t\t\t\t\t\t\ttable.GetCell(row, col).SetBackgroundColor(tcell.ColorDimGrey)\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tstack.Clear()\n\t\t\tfor i, value := range vm.Stack {\n\t\t\t\tstack.SetCellSimple(i, 0, fmt.Sprintf(\"% *d: \", 2, i))\n\t\t\t\tstack.SetCellSimple(i, 1, fmt.Sprintf(\"%#v\", value))\n\t\t\t}\n\t\t\tstack.ScrollToEnd()\n\n\t\t\tscope.Clear()\n\t\t\tvar s *Scope\n\t\t\tif len(vm.Scopes) > 0 {\n\t\t\t\ts = vm.Scopes[len(vm.Scopes)-1]\n\t\t\t}\n\t\t\tif s != nil {\n\t\t\t\ttype pair struct {\n\t\t\t\t\tkey string\n\t\t\t\t\tvalue any\n\t\t\t\t}\n\t\t\t\tvar keys []pair\n\t\t\t\tkeys = append(keys, pair{\"Array\", s.Array})\n\t\t\t\tkeys = append(keys, pair{\"Index\", s.Index})\n\t\t\t\tkeys = append(keys, pair{\"Len\", s.Len})\n\t\t\t\tkeys = append(keys, pair{\"Count\", s.Count})\n\t\t\t\tif s.Acc != nil {\n\t\t\t\t\tkeys = append(keys, pair{\"Acc\", s.Acc})\n\t\t\t\t}\n\t\t\t\trow := 0\n\t\t\t\tfor _, pair := range keys {\n\t\t\t\t\tscope.SetCellSimple(row, 0, fmt.Sprintf(\"%v: \", pair.key))\n\t\t\t\t\tscope.SetCellSimple(row, 1, fmt.Sprintf(\"%v\", pair.value))\n\t\t\t\t\trow++\n\t\t\t\t}\n\t\t\t}\n\t\t})\n\t}\n\n\tgetSelectedPosition := func() int {\n\t\trow, _ := table.GetSelection()\n\t\tip, err := strconv.Atoi(strings.TrimSpace(table.GetCell(row, 0).Text))\n\t\tcheck(err)\n\t\treturn ip\n\t}\n\n\tautostep := false\n\tvar breakpoint int\n\n\tgo func() {\n\t\tdraw(0)\n\t\tfor ip := range vm.Position() {\n\t\t\tdraw(ip)\n\n\t\t\tif autostep {\n\t\t\t\tif breakpoint != ip {\n\t\t\t\t\ttime.Sleep(20 * time.Millisecond)\n\t\t\t\t\tif !done {\n\t\t\t\t\t\tvm.Step()\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tautostep = false\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}()\n\n\tapp.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {\n\t\tif event.Key() == tcell.KeyDown || event.Key() == tcell.KeyUp {\n\t\t\ttable.SetSelectable(true, false)\n\t\t}\n\t\tif event.Key() == tcell.KeyEnter {\n\t\t\tselectable, _ := table.GetSelectable()\n\t\t\tif selectable {\n\t\t\t\ttable.SetSelectable(false, false)\n\t\t\t\tbreakpoint = getSelectedPosition()\n\t\t\t\tautostep = true\n\t\t\t}\n\t\t\tif !done {\n\t\t\t\tvm.Step()\n\t\t\t}\n\t\t}\n\t\treturn event\n\t})\n\n\terr := app.Run()\n\tcheck(err)\n}\n\nfunc check(err error) {\n\tif err != nil {\n\t\t_, _ = fmt.Fprintf(os.Stderr, \"%v\\n\", err)\n\t\tos.Exit(1)\n\t}\n}\n"
},
{
"path": "debug/go.mod",
"content": "module github.com/expr-lang/expr/debug\n\ngo 1.18\n\nrequire (\n\tgithub.com/expr-lang/expr v0.0.0\n\tgithub.com/gdamore/tcell/v2 v2.6.0\n\tgithub.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703\n)\n\nrequire (\n\tgithub.com/gdamore/encoding v1.0.0 // indirect\n\tgithub.com/lucasb-eyer/go-colorful v1.2.0 // indirect\n\tgithub.com/mattn/go-runewidth v0.0.15 // indirect\n\tgithub.com/rivo/uniseg v0.4.4 // indirect\n\tgolang.org/x/sys v0.11.0 // indirect\n\tgolang.org/x/term v0.11.0 // indirect\n\tgolang.org/x/text v0.12.0 // indirect\n)\n\nreplace github.com/expr-lang/expr => ../\n"
},
{
"path": "debug/go.sum",
"content": "github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=\ngithub.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=\ngithub.com/gdamore/tcell/v2 v2.6.0 h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=\ngithub.com/gdamore/tcell/v2 v2.6.0/go.mod h1:be9omFATkdr0D9qewWW3d+MEvl5dha+Etb5y65J2H8Y=\ngithub.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=\ngithub.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=\ngithub.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=\ngithub.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=\ngithub.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=\ngithub.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703 h1:ZyM/+FYnpbZsFWuCohniM56kRoHRB4r5EuIzXEYkpxo=\ngithub.com/rivo/tview v0.0.0-20230814110005-ccc2c8119703/go.mod h1:nVwGv4MP47T0jvlk7KuTTjjuSmrGO4JF0iaiNt4bufE=\ngithub.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=\ngithub.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=\ngithub.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=\ngithub.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=\ngithub.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=\ngolang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=\ngolang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=\ngolang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=\ngolang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=\ngolang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=\ngolang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=\ngolang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=\ngolang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=\ngolang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=\ngolang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=\ngolang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=\ngolang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=\ngolang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=\ngolang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=\ngolang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=\ngolang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=\ngolang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=\ngolang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=\ngolang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=\ngolang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=\ngolang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=\ngolang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=\ngolang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=\ngolang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=\ngolang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=\ngolang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=\n"
},
{
"path": "docgen/README.md",
"content": "# DocGen\n\nThis package provides documentation generator with JSON or Markdown output.\n\n## Usage\n\nCreate a file and put next code into it. \n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n \n\t\"github.com/expr-lang/expr/docgen\"\n)\n\nfunc main() {\n\t// TODO: Replace env with your own types.\n\tdoc := docgen.CreateDoc(env)\n \n\tbuf, err := json.MarshalIndent(doc, \"\", \" \")\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\tfmt.Println(string(buf))\n}\n```\n\nRun `go run your_file.go`. Documentation will be printed in JSON format.\n\n## Markdown\n\nTo generate markdown documentation: \n\n```go\npackage main\n\nimport \"github.com/expr-lang/expr/docgen\"\n\nfunc main() {\n\t// TODO: Replace env with your own types.\n\tdoc := docgen.CreateDoc(env)\n\n\tprint(doc.Markdown())\n}\n```\n"
},
{
"path": "docgen/docgen.go",
"content": "package docgen\n\nimport (\n\t\"reflect\"\n\t\"regexp\"\n\t\"strings\"\n\n\t\"github.com/expr-lang/expr/checker/nature\"\n\t\"github.com/expr-lang/expr/conf\"\n\t\"github.com/expr-lang/expr/internal/deref\"\n)\n\n// Kind can be any of array, map, struct, func, string, int, float, bool or any.\ntype Kind string\n\n// Identifier represents variable names and field names.\ntype Identifier string\n\n// TypeName is a name of type in types map.\ntype TypeName string\n\ntype Context struct {\n\tVariables map[Identifier]*Type `json:\"variables\"`\n\tTypes map[TypeName]*Type `json:\"types\"`\n\tPkgPath string\n}\n\ntype Type struct {\n\tName TypeName `json:\"name,omitempty\"`\n\tKind Kind `json:\"kind,omitempty\"`\n\tType *Type `json:\"type,omitempty\"`\n\tKey *Type `json:\"key_type,omitempty\"`\n\tFields map[Identifier]*Type `json:\"fields,omitempty\"`\n\tArguments []*Type `json:\"arguments,omitempty\"`\n\tReturn *Type `json:\"return,omitempty\"`\n}\n\nvar (\n\tOperators = []string{\"matches\", \"contains\", \"startsWith\", \"endsWith\"}\n\tBuiltins = map[Identifier]*Type{\n\t\t\"true\": {Kind: \"bool\"},\n\t\t\"false\": {Kind: \"bool\"},\n\t\t\"len\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}}, Return: &Type{Kind: \"int\"}},\n\t\t\"all\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"bool\"}},\n\t\t\"none\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"bool\"}},\n\t\t\"any\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"bool\"}},\n\t\t\"one\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"bool\"}},\n\t\t\"filter\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"array\", Type: &Type{Kind: \"any\"}}},\n\t\t\"map\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"array\", Type: &Type{Kind: \"any\"}}},\n\t\t\"count\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Kind: \"func\"}}, Return: &Type{Kind: \"int\"}},\n\n\t\t\"trim\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"cutstr\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\t\t\"trimPrefix\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"cutstr\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\t\t\"trimSuffix\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"cutstr\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\n\t\t\"upper\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\t\t\"lower\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\t\t\"repeat\": {Kind: \"func\", Arguments: []*Type{{Name: \"n\", Kind: \"int\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\n\t\t\"join\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}, {Name: \"glue\", Kind: \"string\"}}, Return: &Type{Name: \"string\", Kind: \"string\"}},\n\t\t\"indexOf\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"substr\", Kind: \"string\"}}, Return: &Type{Name: \"index\", Kind: \"int\"}},\n\t\t\"lastIndexOf\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"substr\", Kind: \"string\"}}, Return: &Type{Name: \"index\", Kind: \"int\"}},\n\n\t\t\"hasPrefix\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"prefix\", Kind: \"string\"}}, Return: &Type{Kind: \"bool\"}},\n\t\t\"hasSuffix\": {Kind: \"func\", Arguments: []*Type{{Name: \"string\", Kind: \"string\"}, {Name: \"prefix\", Kind: \"string\"}}, Return: &Type{Kind: \"bool\"}},\n\n\t\t\"toJSON\": {Kind: \"func\", Arguments: []*Type{{Kind: \"any\"}}, Return: &Type{Kind: \"string\"}},\n\t\t\"fromJSON\": {Kind: \"func\", Arguments: []*Type{{Kind: \"string\"}}, Return: &Type{Kind: \"any\"}},\n\n\t\t\"toBase64\": {Kind: \"func\", Arguments: []*Type{{Kind: \"string\"}}, Return: &Type{Kind: \"string\"}},\n\t\t\"fromBase64\": {Kind: \"func\", Arguments: []*Type{{Kind: \"string\"}}, Return: &Type{Kind: \"string\"}},\n\n\t\t\"first\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}}, Return: &Type{Kind: \"any\"}},\n\t\t\"last\": {Kind: \"func\", Arguments: []*Type{{Kind: \"array\", Type: &Type{Kind: \"any\"}}}, Return: &Type{Kind: \"any\"}},\n\n\t\t\"now\": {Kind: \"func\", Return: &Type{Name: \"time.Time\", Kind: \"struct\"}},\n\t\t\"duration\": {Kind: \"func\", Arguments: []*Type{{Kind: \"string\"}}, Return: &Type{Kind: \"time.Duration\"}},\n\t}\n)\n\nfunc CreateDoc(i any) *Context {\n\tc := &Context{\n\t\tVariables: make(map[Identifier]*Type),\n\t\tTypes: make(map[TypeName]*Type),\n\t\tPkgPath: deref.Type(reflect.TypeOf(i)).PkgPath(),\n\t}\n\n\tcache := new(nature.Cache)\n\tenv := conf.EnvWithCache(cache, i)\n\tfor name, t := range env.All(cache) {\n\t\tif _, ok := c.Variables[Identifier(name)]; ok {\n\t\t\tcontinue\n\t\t}\n\t\tc.Variables[Identifier(name)] = c.use(t.Type, fromMethod(t.Method))\n\t}\n\n\tfor _, op := range Operators {\n\t\tc.Variables[Identifier(op)] = &Type{\n\t\t\tKind: \"operator\",\n\t\t}\n\t}\n\n\tfor builtin, t := range Builtins {\n\t\tc.Variables[builtin] = t\n\t}\n\n\treturn c\n}\n\ntype config struct {\n\tmethod bool\n}\n\ntype option func(c *config)\n\nfunc fromMethod(b bool) option {\n\treturn func(c *config) {\n\t\tc.method = b\n\t}\n}\n\nfunc (c *Context) use(t reflect.Type, ops ...option) *Type {\n\tconfig := &config{}\n\tfor _, op := range ops {\n\t\top(config)\n\t}\n\n\tmethods := make([]reflect.Method, 0)\n\n\t// Methods of struct should be gathered from original struct with pointer,\n\t// as methods maybe declared on pointer receiver. Also this method retrieves\n\t// all embedded structs methods as well, no need to recursion.\n\tfor i := 0; i < t.NumMethod(); i++ {\n\t\tm := t.Method(i)\n\t\tif isPrivate(m.Name) || isProtobuf(m.Name) {\n\t\t\tcontinue\n\t\t}\n\t\tmethods = append(methods, m)\n\t}\n\n\tt = deref.Type(t)\n\n\t// Only named types will have methods defined on them.\n\t// It maybe not even struct, but we gonna call then\n\t// structs in appendix anyway.\n\tif len(methods) > 0 {\n\t\tgoto appendix\n\t}\n\n\t// This switch only for \"simple\" types.\n\tswitch t.Kind() {\n\tcase reflect.Bool:\n\t\treturn &Type{Kind: \"bool\"}\n\n\tcase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:\n\t\tfallthrough\n\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:\n\t\treturn &Type{Kind: \"int\"}\n\n\tcase reflect.Float32, reflect.Float64:\n\t\treturn &Type{Kind: \"float\"}\n\n\tcase reflect.String:\n\t\treturn &Type{Kind: \"string\"}\n\n\tcase reflect.Interface:\n\t\treturn &Type{Kind: \"any\"}\n\n\tcase reflect.Array, reflect.Slice:\n\t\treturn &Type{\n\t\t\tKind: \"array\",\n\t\t\tType: c.use(t.Elem()),\n\t\t}\n\n\tcase reflect.Map:\n\t\treturn &Type{\n\t\t\tKind: \"map\",\n\t\t\tKey: c.use(t.Key()),\n\t\t\tType: c.use(t.Elem()),\n\t\t}\n\n\tcase reflect.Struct:\n\t\tgoto appendix\n\n\tcase reflect.Func:\n\t\targuments := make([]*Type, 0)\n\t\tstart := 0\n\t\tif config.method {\n\t\t\tstart = 1\n\t\t}\n\t\tfor i := start; i < t.NumIn(); i++ {\n\t\t\targuments = append(arguments, c.use(t.In(i)))\n\t\t}\n\t\tf := &Type{\n\t\t\tKind: \"func\",\n\t\t\tArguments: arguments,\n\t\t}\n\t\tif t.NumOut() > 0 {\n\t\t\tf.Return = c.use(t.Out(0))\n\t\t}\n\t\treturn f\n\t}\n\nappendix:\n\n\tname := TypeName(t.String())\n\tif c.PkgPath == t.PkgPath() {\n\t\tname = TypeName(t.Name())\n\t}\n\tanonymous := t.Name() == \"\"\n\n\ta, ok := c.Types[name]\n\n\tif !ok {\n\t\ta = &Type{\n\t\t\tKind: \"struct\",\n\t\t\tFields: make(map[Identifier]*Type),\n\t\t}\n\n\t\t// baseNode a should be saved before starting recursion, or it will never end.\n\t\tif !anonymous {\n\t\t\tc.Types[name] = a\n\t\t}\n\n\t\tntCache := new(nature.Cache)\n\t\tfor name, field := range nature.StructFields(ntCache, t) {\n\t\t\tif isPrivate(name) || isProtobuf(name) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif _, ok := a.Fields[Identifier(name)]; ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\ta.Fields[Identifier(name)] = c.use(field.Type)\n\t\t}\n\n\t\tfor _, m := range methods {\n\t\t\tif isPrivate(m.Name) || isProtobuf(m.Name) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\ta.Fields[Identifier(m.Name)] = c.use(m.Type, fromMethod(true))\n\t\t}\n\t}\n\n\tif anonymous {\n\t\treturn a\n\t}\n\n\treturn &Type{\n\t\tKind: \"struct\",\n\t\tName: name,\n\t}\n}\n\nvar isCapital = regexp.MustCompile(\"^[A-Z]\")\n\nfunc isPrivate(s string) bool {\n\treturn !isCapital.Match([]byte(s))\n}\n\nfunc isProtobuf(s string) bool {\n\treturn strings.HasPrefix(s, \"XXX_\")\n}\n"
},
{
"path": "docgen/docgen_test.go",
"content": "package docgen_test\n\nimport (\n\t\"math\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/expr-lang/expr/internal/testify/assert\"\n\t\"github.com/expr-lang/expr/internal/testify/require\"\n\n\t. \"github.com/expr-lang/expr/docgen\"\n)\n\ntype Tweet struct {\n\tSize int\n\tMessage string\n}\n\ntype Env struct {\n\tTweets []Tweet\n\tConfig struct {\n\t\tMaxSize int32\n\t}\n\tEnv map[string]any\n\t// NOTE: conflicting type name\n\tTimeWeekday time.Weekday\n\tWeekday Weekday\n}\n\ntype Weekday int\n\nfunc (Weekday) String() string {\n\treturn \"\"\n}\n\ntype Duration int\n\nfunc (Duration) String() string {\n\treturn \"\"\n}\n\nfunc (*Env) Duration(s string) Duration {\n\treturn Duration(0)\n}\n\nfunc TestCreateDoc(t *testing.T) {\n\tOperators = nil\n\tBuiltins = nil\n\tdoc := CreateDoc(&Env{})\n\texpected := &Context{\n\t\tVariables: map[Identifier]*Type{\n\t\t\t\"Tweets\": {\n\t\t\t\tKind: \"array\",\n\t\t\t\tType: &Type{\n\t\t\t\t\tKind: \"struct\",\n\t\t\t\t\tName: \"Tweet\",\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Config\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"MaxSize\": {Kind: \"int\"},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Env\": {\n\t\t\t\tKind: \"map\",\n\t\t\t\tKey: &Type{Kind: \"string\"},\n\t\t\t\tType: &Type{Kind: \"any\"},\n\t\t\t},\n\t\t\t\"Duration\": {\n\t\t\t\tKind: \"func\",\n\t\t\t\tArguments: []*Type{\n\t\t\t\t\t{Kind: \"string\"},\n\t\t\t\t},\n\t\t\t\tReturn: &Type{Kind: \"struct\", Name: \"Duration\"},\n\t\t\t},\n\t\t\t\"TimeWeekday\": {\n\t\t\t\tName: \"time.Weekday\",\n\t\t\t\tKind: \"struct\",\n\t\t\t},\n\t\t\t\"Weekday\": {\n\t\t\t\tName: \"Weekday\",\n\t\t\t\tKind: \"struct\",\n\t\t\t},\n\t\t},\n\t\tTypes: map[TypeName]*Type{\n\t\t\t\"Tweet\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"Size\": {Kind: \"int\"},\n\t\t\t\t\t\"Message\": {Kind: \"string\"},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Duration\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"String\": {\n\t\t\t\t\t\tKind: \"func\",\n\t\t\t\t\t\tArguments: []*Type{},\n\t\t\t\t\t\tReturn: &Type{\n\t\t\t\t\t\t\tKind: \"string\",\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"time.Weekday\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"String\": {\n\t\t\t\t\t\tKind: \"func\",\n\t\t\t\t\t\tArguments: []*Type{},\n\t\t\t\t\t\tReturn: &Type{\n\t\t\t\t\t\t\tKind: \"string\",\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Weekday\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"String\": {\n\t\t\t\t\t\tKind: \"func\",\n\t\t\t\t\t\tArguments: []*Type{},\n\t\t\t\t\t\tReturn: &Type{\n\t\t\t\t\t\t\tKind: \"string\",\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t\tPkgPath: \"github.com/expr-lang/expr/docgen_test\",\n\t}\n\n\tassert.Equal(t, expected.Markdown(), doc.Markdown())\n}\n\ntype A struct {\n\tAmbiguousField int\n\tOkField int\n}\ntype B struct {\n\tAmbiguousField string\n}\n\ntype C struct {\n\tA\n\tB\n}\ntype EnvAmbiguous struct {\n\tA\n\tB\n\tC C\n}\n\nfunc TestCreateDoc_Ambiguous(t *testing.T) {\n\tdoc := CreateDoc(&EnvAmbiguous{})\n\texpected := &Context{\n\t\tVariables: map[Identifier]*Type{\n\t\t\t\"A\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tName: \"A\",\n\t\t\t},\n\t\t\t\"AmbiguousField\": {\n\t\t\t\tKind: \"int\",\n\t\t\t},\n\t\t\t\"B\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tName: \"B\",\n\t\t\t},\n\t\t\t\"OkField\": {\n\t\t\t\tKind: \"int\",\n\t\t\t},\n\t\t\t\"C\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tName: \"C\",\n\t\t\t},\n\t\t},\n\t\tTypes: map[TypeName]*Type{\n\t\t\t\"A\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"AmbiguousField\": {Kind: \"int\"},\n\t\t\t\t\t\"OkField\": {Kind: \"int\"},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"B\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"AmbiguousField\": {Kind: \"string\"},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"C\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"A\": {Kind: \"struct\", Name: \"A\"},\n\t\t\t\t\t\"AmbiguousField\": {Kind: \"int\"},\n\t\t\t\t\t\"B\": {Kind: \"struct\", Name: \"B\"},\n\t\t\t\t\t\"OkField\": {Kind: \"int\"},\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t\tPkgPath: \"github.com/expr-lang/expr/docgen_test\",\n\t}\n\n\tassert.Equal(t, expected.Markdown(), doc.Markdown())\n}\n\nfunc TestCreateDoc_FromMap(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"Tweets\": []*Tweet{},\n\t\t\"Config\": struct {\n\t\t\tMaxSize int\n\t\t}{},\n\t\t\"Max\": math.Max,\n\t}\n\tOperators = nil\n\tBuiltins = nil\n\tdoc := CreateDoc(env)\n\texpected := &Context{\n\t\tVariables: map[Identifier]*Type{\n\t\t\t\"Tweets\": {\n\t\t\t\tKind: \"array\",\n\t\t\t\tType: &Type{\n\t\t\t\t\tKind: \"struct\",\n\t\t\t\t\tName: \"docgen_test.Tweet\",\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Config\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"MaxSize\": {Kind: \"int\"},\n\t\t\t\t},\n\t\t\t},\n\t\t\t\"Max\": {\n\t\t\t\tKind: \"func\",\n\t\t\t\tArguments: []*Type{\n\t\t\t\t\t{Kind: \"float\"},\n\t\t\t\t\t{Kind: \"float\"},\n\t\t\t\t},\n\t\t\t\tReturn: &Type{Kind: \"float\"},\n\t\t\t},\n\t\t},\n\t\tTypes: map[TypeName]*Type{\n\t\t\t\"docgen_test.Tweet\": {\n\t\t\t\tKind: \"struct\",\n\t\t\t\tFields: map[Identifier]*Type{\n\t\t\t\t\t\"Size\": {Kind: \"int\"},\n\t\t\t\t\t\"Message\": {Kind: \"string\"},\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t}\n\n\trequire.EqualValues(t, expected.Markdown(), doc.Markdown())\n}\n\nfunc TestContext_Markdown(t *testing.T) {\n\tdoc := CreateDoc(&Env{})\n\tmd := doc.Markdown()\n\trequire.True(t, len(md) > 0)\n}\n"
},
{
"path": "docgen/markdown.go",
"content": "package docgen\n\nimport (\n\t\"fmt\"\n\t\"sort\"\n\t\"strings\"\n)\n\nfunc (c *Context) Markdown() string {\n\tvar variables []string\n\tfor name := range c.Variables {\n\t\tvariables = append(variables, string(name))\n\t}\n\n\tvar types []string\n\tfor name := range c.Types {\n\t\ttypes = append(types, string(name))\n\t}\n\n\tsort.Strings(variables)\n\tsort.Strings(types)\n\n\tout := `### Variables\n| Name | Type |\n|------|------|\n`\n\tfor _, name := range variables {\n\t\tv := c.Variables[Identifier(name)]\n\t\tif v.Kind == \"func\" {\n\t\t\tcontinue\n\t\t}\n\t\tif v.Kind == \"operator\" {\n\t\t\tcontinue\n\t\t}\n\t\tout += fmt.Sprintf(\"| %v | %v |\\n\", name, link(v))\n\t}\n\n\tout += `\n### Functions\n| Name | Return type |\n|------|-------------|\n`\n\tfor _, name := range variables {\n\t\tv := c.Variables[Identifier(name)]\n\t\tif v.Kind == \"func\" {\n\t\t\targs := make([]string, len(v.Arguments))\n\t\t\tfor i, arg := range v.Arguments {\n\t\t\t\targs[i] = link(arg)\n\t\t\t}\n\t\t\tout += fmt.Sprintf(\"| %v(%v) | %v |\\n\", name, strings.Join(args, \", \"), link(v.Return))\n\t\t}\n\t}\n\n\tout += \"\\n### Types\\n\"\n\tfor _, name := range types {\n\t\tt := c.Types[TypeName(name)]\n\t\tout += fmt.Sprintf(\"#### %v\\n\", name)\n\t\tout += fields(t)\n\t\tout += \"\\n\"\n\t}\n\n\treturn out\n}\n\nfunc link(t *Type) string {\n\tif t == nil {\n\t\treturn \"nil\"\n\t}\n\tif t.Name != \"\" {\n\t\treturn fmt.Sprintf(\"[%v](#%v)\", t.Name, t.Name)\n\t}\n\tif t.Kind == \"array\" {\n\t\treturn fmt.Sprintf(\"array(%v)\", link(t.Type))\n\t}\n\tif t.Kind == \"map\" {\n\t\treturn fmt.Sprintf(\"map(%v => %v)\", link(t.Key), link(t.Type))\n\t}\n\treturn fmt.Sprintf(\"`%v`\", t.Kind)\n}\n\nfunc fields(t *Type) string {\n\tvar fields []string\n\tfor field := range t.Fields {\n\t\tfields = append(fields, string(field))\n\t}\n\tsort.Strings(fields)\n\n\tout := \"\"\n\tfoundFields := false\n\tfor _, name := range fields {\n\t\tv := t.Fields[Identifier(name)]\n\t\tif v.Kind != \"func\" {\n\t\t\tif !foundFields {\n\t\t\t\tout += \"| Field | Type |\\n|---|---|\\n\"\n\t\t\t}\n\t\t\tfoundFields = true\n\n\t\t\tout += fmt.Sprintf(\"| %v | %v |\\n\", name, link(v))\n\t\t}\n\t}\n\tfoundMethod := false\n\tfor _, name := range fields {\n\t\tv := t.Fields[Identifier(name)]\n\t\tif v.Kind == \"func\" {\n\t\t\tif !foundMethod {\n\t\t\t\tout += \"\\n| Method | Returns |\\n|---|---|\\n\"\n\t\t\t}\n\t\t\tfoundMethod = true\n\n\t\t\targs := make([]string, len(v.Arguments))\n\t\t\tfor i, arg := range v.Arguments {\n\t\t\t\targs[i] = link(arg)\n\t\t\t}\n\t\t\tout += fmt.Sprintf(\"| %v(%v) | %v |\\n\", name, strings.Join(args, \", \"), link(v.Return))\n\t\t}\n\t}\n\treturn out\n}\n"
},
{
"path": "docs/configuration.md",
"content": "# Configuration\n\n## Return type\n\nUsually, the return type of expression is anything. But we can instruct type checker to verify the return type of the\nexpression.\nFor example, in filter expressions, we expect the return type to be a boolean.\n\n```go\nprogram, err := expr.Compile(code, expr.AsBool())\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, env)\nif err != nil {\n panic(err)\n}\n\nok := output.(bool) // It is safe to assert the output to bool, if the expression is type checked as bool.\n```\n\nIf `code` variable for example returns a string, the compiler will return an error.\n\nExpr has a few options to specify the return type:\n\n- [expr.AsBool()](https://pkg.go.dev/github.com/expr-lang/expr#AsBool) - expects the return type to be a bool.\n- [expr.AsInt()](https://pkg.go.dev/github.com/expr-lang/expr#AsInt) - expects the return type to be an int (float64,\n uint, int32, and other will be cast to int).\n- [expr.AsInt64()](https://pkg.go.dev/github.com/expr-lang/expr#AsInt64) - expects the return type to be an int64 (\n float64, uint, int32, and other will be cast to int64).\n- [expr.AsFloat64()](https://pkg.go.dev/github.com/expr-lang/expr#AsFloat64) - expects the return type to be a float64 (\n float32 will be cast to float64).\n- [expr.AsAny()](https://pkg.go.dev/github.com/expr-lang/expr#AsAny) - expects the return type to be anything.\n- [expr.AsKind(reflect.Kind)](https://pkg.go.dev/github.com/expr-lang/expr#AsKind) - expects the return type to be a\n specific kind.\n\n:::tip Warn on any\nBy default, type checker will accept any type, even if the return type is specified. Consider following examples:\n\n```expr\nlet arr = [1, 2, 3]; arr[0]\n```\n\nThe return type of the expression is `any`. Arrays created in Expr are of type `[]any`. The type checker will not return\nan error if the return type is specified as `expr.AsInt()`. The output of the expression is `1`, which is an int, but the\ntype checker will not return an error.\n\nBut we can instruct the type checker to warn us if the return type is `any`. Use [`expr.WarnOnAny()`](https://pkg.go.dev/github.com/expr-lang/expr#WarnOnAny) to enable this behavior.\n\n```go\nprogram, err := expr.Compile(code, expr.AsInt(), expr.WarnOnAny())\n```\n\nThe type checker will return an error if the return type is `any`. We need to modify the expression to return a specific\ntype.\n\n```expr\nlet arr = [1, 2, 3]; int(arr[0])\n```\n:::\n\n\n## WithContext\n\nAlthough the compiled program is guaranteed to be terminated, some user defined functions may not be. For example, if a\nuser defined function calls a remote service, we may want to pass a context to the function.\n\nThis is possible via the [`WithContext`](https://pkg.go.dev/github.com/expr-lang/expr#WithContext) option.\n\nThis option will modify function calls to include the context as the first argument (only if the function signature\naccepts a context).\n\n```expr\ncustomFunc(42)\n// will be transformed to\ncustomFunc(ctx, 42)\n```\n\nFunction `expr.WithContext()` takes the name of context variable. The context variable must be defined in the environment.\n\n```go\nenv := map[string]any{\n \"ctx\": context.Background(),\n \"customFunc\": func(ctx context.Context, a int) int {\n return a\n },\n}\n\nprogram, err := expr.Compile(code, expr.Env(env), expr.WithContext(\"ctx\"))\n```\n\n## ConstExpr\n\nFor some user defined functions, we may want to evaluate the expression at compile time. This is possible via the\n[`ConstExpr`](https://pkg.go.dev/github.com/expr-lang/expr#ConstExpr) option. \n\n```go\nfunc fib(n int) int {\n if n <= 1 {\n return n\n }\n return fib(n-1) + fib(n-2)\n}\n\nenv := map[string]any{\n \"fib\": fib,\n}\n\nprogram, err := expr.Compile(`fib(10)`, expr.Env(env), expr.ConstExpr(\"fib\"))\n```\n\nIf all arguments of the function are constants, the function will be evaluated at compile time. The result of the function\nwill be used as a constant in the expression.\n\n```expr\nfib(10) // will be transformed to 55 during the compilation\nfib(12+12) // will be transformed to 267914296 during the compilation\nfib(x) // will **not** be transformed and will be evaluated at runtime\n```\n\n## Timezone\n\nBy default, the timezone is set to `time.Local`. We can change the timezone via the [`Timezone`](https://pkg.go.dev/github.com/expr-lang/expr#Timezone) option.\n\n```go\nprogram, err := expr.Compile(code, expr.Timezone(time.UTC))\n```\n\nThe timezone is used for the following functions:\n```expr\ndate(\"2024-11-23 12:00:00\") // parses the date in the specified timezone\nnow() // returns the current time in the specified timezone\n```\n"
},
{
"path": "docs/environment.md",
"content": "# Environment\n\nThe environment is a map or a struct that contains the variables and functions that the expression can access.\n\n## Struct as Environment\n\nLet's consider the following example:\n\n```go\ntype Env struct {\n UpdatedAt time.Time\n Posts []Post\n Map map[string]string `expr:\"tags\"`\n}\n```\n\nThe `Env` struct contains 3 variables that the expression can access: `UpdatedAt`, `Posts`, and `tags`.\n\n:::info\nThe `expr` tag is used to rename the `Map` field to `tags` variable in the expression.\n:::\n\nThe `Env` struct can also contain methods. The methods defined on the struct become functions that the expression can\ncall.\n\n```go\nfunc (Env) Format(t time.Time) string {\n return t.Format(time.RFC822)\n}\n```\n\n:::tip\nMethods defined on embedded structs are also accessible.\n```go\ntype Env struct {\n Helpers\n}\n\ntype Helpers struct{}\n\nfunc (Helpers) Format(t time.Time) string {\n return t.Format(time.RFC822)\n}\n```\n:::\n\nWe can use an empty struct `Env{}` to with [expr.Env](https://pkg.go.dev/github.com/expr-lang/expr#Env) to create an environment. Expr will use reflection to find \nthe fields and methods of the struct.\n\n```go\nprogram, err := expr.Compile(code, expr.Env(Env{}))\n```\n\nCompiler will type check the expression against the environment. After the compilation, we can run the program with the environment.\nYou should use the same type of environment that you passed to the `expr.Env` function.\n\n```go\noutput, err := expr.Run(program, Env{\n UpdatedAt: time.Now(),\n Posts: []Post{{Title: \"Hello, World!\"}},\n Map: map[string]string{\"tag1\": \"value1\"},\n})\n```\n\n## Map as Environment\n\nYou can also use a map as an environment.\n\n```go\nenv := map[string]any{\n \"UpdatedAt\": time.Time{},\n \"Posts\": []Post{},\n \"tags\": map[string]string{},\n \"sprintf\": fmt.Sprintf,\n}\n\nprogram, err := expr.Compile(code, expr.Env(env))\n```\n\nA map defines variables and functions that the expression can access. The key is the variable name, and the type\nis the value's type.\n\n```go\nenv := map[string]any{\n \"object\": map[string]any{\n \"field\": 42,\n },\n \"struct\": struct {\n Field int `expr:\"field\"`\n }{42},\n}\n```\n\nExpr will infer the type of the `object` variable as `map[string]any`.\nAccessing fields of the `object` and `struct` variables will return the following results.\n\n```expr\nobject.field // 42\nobject.unknown // nil (no error)\n\nstruct.field // 42\nstruct.unknown // error (unknown field)\n\nfoobar // error (unknown variable)\n```\n\n:::note\nThe `foobar` variable is not defined in the environment.\nBy default, Expr will return an error if unknown variables are used in the expression.\nYou can disable this behavior by passing [`AllowUndefinedVariables`](https://pkg.go.dev/github.com/expr-lang/expr#AllowUndefinedVariables) option to the compiler.\n:::\n"
},
{
"path": "docs/functions.md",
"content": "# Functions\n\nExpr comes with a set of [builtin](language-definition.md) functions, but you can also define your own functions.\n\nThe easiest way to define a custom function is to add it to the environment.\n\n```go\nenv := map[string]any{\n \"add\": func(a, b int) int {\n return a + b\n },\n}\n```\n\nOr you can use functions defined on a struct:\n\n```go\ntype Env struct{}\n\nfunc (Env) Add(a, b int) int {\n return a + b\n}\n```\n\n:::info\nIf functions are marked with [`ConstExpr`](./configuration.md#constexpr) option, they will be evaluated at compile time.\n:::\n\nThe best way to define a function from a performance perspective is to use a [`Function`](https://pkg.go.dev/github.com/expr-lang/expr#Function) option.\n\n```go\natoi := expr.Function(\n \"atoi\",\n func(params ...any) (any, error) {\n return strconv.Atoi(params[0].(string))\n },\n)\n\nprogram, err := expr.Compile(`atoi(\"42\")`, atoi)\n```\n\nType checker sees the `atoi` function as a function with a variadic number of arguments of type `any`, and returns \na value of type `any`. But, we can specify the types of arguments and the return value by adding the correct function \nsignature or multiple signatures.\n\n```go\natoi := expr.Function(\n \"atoi\",\n func(params ...any) (any, error) {\n return strconv.Atoi(params[0].(string))\n },\n // highlight-next-line\n new(func(string) int),\n)\n```\n\nOr we can simply reuse the strconv.Atoi function as a type:\n\n```go\natoi := expr.Function(\n \"atoi\",\n func(params ...any) (any, error) {\n return strconv.Atoi(params[0].(string))\n },\n // highlight-next-line\n strconv.Atoi,\n)\n```\n\nIt is possible to define multiple signatures for a function:\n\n```go\ntoInt := expr.Function(\n \"toInt\",\n func(params ...any) (any, error) {\n switch params[0].(type) {\n case float64:\n return int(params[0].(float64)), nil\n case string:\n return strconv.Atoi(params[0].(string))\n }\n return nil, fmt.Errorf(\"invalid type\")\n },\n // highlight-start\n new(func(float64) int),\n new(func(string) int),\n // highlight-end\n)\n```\n"
},
{
"path": "docs/getting-started.md",
"content": "# Getting Started\n\n**Expr** is a simple, fast and extensible expression language for Go. It is\ndesigned to be easy to use and integrate into your Go application. Let's delve\ndeeper into its core features:\n\n- **Memory safe** - Designed to prevent vulnerabilities like buffer overflows and memory leaks.\n- **Type safe** - Enforces strict type rules, aligning with Go's type system.\n- **Terminating** - Ensures every expression evaluation cannot loop indefinitely.\n- **Side effects free** - Evaluations won't modify global states or variables.\n\nLet's start with a simple example:\n\n```go\nprogram, err := expr.Compile(`2 + 2`)\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, nil)\nif err != nil {\n panic(err)\n}\n\nfmt.Print(output) // 4\n```\n\nExpr compiles the expression `2 + 2` into a bytecode program. Then we run\nthe program and get the output.\n\n:::tip\nIn performance-critical applications, you can reuse the compiled program. Compiled programs are safe for concurrent use.\n**Compile once** and run **multiple** times.\n:::\n\nThe `expr.Compile` function returns a `*vm.Program` and an error. The `expr.Run` function takes a program and an\nenvironment. The environment is a map of variables that can be used in the expression. In this example, we use `nil` as\nan environment because we don't need any variables.\n\n\nNow let's pass some variables to the expression:\n\n```go\nenv := map[string]any{\n \"foo\": 100,\n \"bar\": 200,\n}\n\nprogram, err := expr.Compile(`foo + bar`, expr.Env(env))\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, env)\nif err != nil {\n panic(err)\n}\n\nfmt.Print(output) // 300\n```\n\nWhy do we need to pass the environment to the `expr.Compile` function? Expr can be used as a type-safe language. \nExpr can infer the type of the expression and check it against the environment. \n\nHere is an example:\n\n```go\nenv := map[string]any{\n \"name\": \"Anton\",\n \"age\": 35,\n}\n\nprogram, err := expr.Compile(`name + age`, expr.Env(env))\nif err != nil {\n // highlight-next-line\n panic(err) // Will panic with \"invalid operation: string + int\"\n}\n```\n\nExpr can work with any Go types:\n\n```go\nenv := map[string]any{\n \"greet\": \"Hello, %v!\",\n \"names\": []string{\"world\", \"you\"},\n \"sprintf\": fmt.Sprintf,\n}\n\nprogram, err := expr.Compile(`sprintf(greet, names[0])`, expr.Env(env))\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, env)\nif err != nil {\n panic(err)\n}\n\nfmt.Print(output) // Hello, world!\n```\n\nAlso, Expr can use a struct as an environment. Here is an example:\n\n```go\ntype Env struct {\n Posts []Post `expr:\"posts\"`\n}\n\nfunc (Env) Format(t time.Time) string { // Methods defined on the struct become functions. \n return t.Format(time.RFC822) \n}\n\ntype Post struct {\n Body string\n Date time.Time\n}\n\nfunc main() {\n code := `map(posts, Format(.Date) + \": \" + .Body)`\n \n program, err := expr.Compile(code, expr.Env(Env{})) // Pass the struct as an environment.\n if err != nil {\n panic(err)\n }\n\n env := Env{\n Posts: []Post{\n {\"Oh My God!\", time.Now()}, \n {\"How you doin?\", time.Now()}, \n {\"Could I be wearing any more clothes?\", time.Now()},\n },\n }\n\n output, err := expr.Run(program, env)\n if err != nil {\n panic(err)\n }\n\n fmt.Print(output)\n}\n```\n\nThe compiled program can be reused between runs.\n\n```go\ntype Env struct {\n X int\n Y int\n}\n\nprogram, err := expr.Compile(`X + Y`, expr.Env(Env{}))\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, Env{1, 2})\nif err != nil {\n panic(err)\n}\n\nfmt.Print(output) // 3\n\noutput, err = expr.Run(program, Env{3, 4})\nif err != nil {\n panic(err)\n}\n\nfmt.Print(output) // 7\n```\n\n:::info Eval = Compile + Run\nFor one-off expressions, you can use the `expr.Eval` function. It compiles and runs the expression in one step.\n```go\noutput, err := expr.Eval(`2 + 2`, env)\n```\n:::\n"
},
{
"path": "docs/language-definition.md",
"content": "# Language Definition\n\n**Expr** is a simple expression language that can be used to evaluate expressions.\n\n## Literals\n\n\n \n | Comment | \n \n /* */ or //\n | \n
\n \n | Boolean | \n \n true, false\n | \n
\n \n | Integer | \n \n 42, 0x2A, 0o52, 0b101010\n | \n
\n \n | Float | \n \n 0.5, .5\n | \n
\n \n | String | \n \n \"foo\", 'bar'\n | \n
\n \n | Array | \n \n [1, 2, 3]\n | \n
\n \n | Map | \n \n {a: 1, b: 2, c: 3}\n | \n
\n \n | Nil | \n \n nil\n | \n
\n \n | Bytes | \n \n b\"hello\", b'\\xff\\x00'\n | \n
\n
\n\n### Strings\n\nStrings can be enclosed in single quotes or double quotes. Strings can contain escape sequences, like `\\n` for newline,\n`\\t` for tab, `\\uXXXX` for Unicode code points.\n\n```expr\n\"Hello\\nWorld\"\n```\n\nFor multiline strings, use backticks:\n\n```expr\n`Hello\nWorld`\n```\n\nBackticks strings are raw strings, they do not support escape sequences.\n\n### Bytes\n\nBytes literals are represented by string literals preceded by a `b` or `B` character.\nThe bytes literal returns a `[]byte` value.\n\n```expr\nb\"abc\" // []byte{97, 98, 99}\n```\n\nNon-ASCII characters are UTF-8 encoded:\n\n```expr\nb\"ÿ\" // []byte{195, 191} - UTF-8 encoding of ÿ\n```\n\nBytes literals support escape sequences for specifying arbitrary byte values:\n\n- `\\xNN` - hexadecimal escape (2 hex digits, value 0-255)\n- `\\NNN` - octal escape (3 octal digits, value 0-377)\n- `\\n`, `\\t`, `\\r`, etc. - standard escape sequences\n\n```expr\nb\"\\xff\" // []byte{255}\nb\"\\x00\\x01\" // []byte{0, 1}\nb\"\\101\" // []byte{65} - octal for 'A'\n```\n\n:::note\nUnlike string literals, bytes literals do not support `\\u` or `\\U` Unicode escapes.\nUse `\\x` escapes for arbitrary byte values.\n:::\n\n## Operators\n\n\n \n | Arithmetic | \n \n +, -, *, /, % (modulus), ^ or ** (exponent)\n | \n
\n \n | Comparison | \n \n ==, !=, <, >, <=, >=\n | \n
\n \n | Logical | \n \n not or !, and or &&, or or ||\n | \n
\n \n | Conditional | \n \n ?: (ternary), ?? (nil coalescing), if {} else {} (multiline)\n | \n
\n \n | Membership | \n \n [], ., ?., in\n | \n
\n \n | String | \n \n + (concatenation), contains, startsWith, endsWith\n | \n
\n \n | Regex | \n \n matches\n | \n
\n \n | Range | \n \n ..\n | \n
\n \n | Slice | \n \n [:]\n | \n
\n \n | Pipe | \n \n |\n | \n
\n
\n\n### Membership Operator\n\nFields of structs and items of maps can be accessed with `.` operator\nor `[]` operator. Next two expressions are equivalent:\n\n```expr\nuser.Name\nuser[\"Name\"]\n``` \n\nElements of arrays and slices can be accessed with\n`[]` operator. Negative indices are supported with `-1` being\nthe last element.\n\n```expr\narray[0] // first element\narray[-1] // last element\n```\n\nThe `in` operator can be used to check if an item is in an array or a map.\n\n```expr\n\"John\" in [\"John\", \"Jane\"]\n\"name\" in {\"name\": \"John\", \"age\": 30}\n```\n\n#### Optional chaining\n\nThe `?.` operator can be used to access a field of a struct or an item of a map\nwithout checking if the struct or the map is `nil`. If the struct or the map is\n`nil`, the result of the expression is `nil`.\n\n```expr\nauthor.User?.Name\n```\n\nIs equivalent to:\n\n```expr\nauthor.User != nil ? author.User.Name : nil\n```\n\n#### Nil coalescing\n\nThe `??` operator can be used to return the left-hand side if it is not `nil`,\notherwise the right-hand side is returned.\n\n```expr\nauthor.User?.Name ?? \"Anonymous\"\n```\n\nIs equivalent to:\n\n```expr\nauthor.User != nil ? author.User.Name : \"Anonymous\"\n```\n\n### Slice Operator\n\nThe slice operator `[:]` can be used to access a slice of an array.\n\nFor example, variable **array** is `[1, 2, 3, 4, 5]`:\n\n```expr\narray[1:4] == [2, 3, 4]\narray[1:-1] == [2, 3, 4]\narray[:3] == [1, 2, 3]\narray[3:] == [4, 5]\narray[:] == array\n```\n\n### Pipe Operator\n\nThe pipe operator `|` can be used to pass the result of the left-hand side\nexpression as the first argument of the right-hand side expression.\n\n```expr\nuser.Name | lower() | split(\" \")\n```\n\nIs equivalent to:\n\n```expr\nsplit(lower(user.Name), \" \")\n```\n\n### Range Operator\n\nThe range operator `..` can be used to create a range of integers.\n\n```expr\n1..3 == [1, 2, 3]\n```\n\n## Variables\n\nVariables can be declared with the `let` keyword. The variable name must start with a letter or an underscore.\nThe variable name can contain letters, digits and underscores. After the variable is declared, it can be used in the\nexpression.\n\n```expr\nlet x = 42; x * 2\n```\n\nA few variables can be declared by a few `let` statements separated by a semicolon.\n\n```expr\nlet x = 42; \nlet y = 2; \nx * y\n```\n\nHere is an example of variable with pipe operator:\n\n```expr\nlet name = user.Name | lower() | split(\" \"); \n\"Hello, \" + name[0] + \"!\"\n```\n\n### $env\n\nThe `$env` variable is a map of all variables passed to the expression.\n\n```expr\nfoo.Name == $env[\"foo\"].Name\n$env[\"var with spaces\"]\n```\n\nThink of `$env` as a global variable that contains all variables.\n\nThe `$env` can be used to check if a variable is defined:\n\n```expr\n'foo' in $env\n```\n\n## Predicate\n\nThe predicate is an expression. Predicates can be used in functions like `filter`, `all`, `any`, `one`, `none`, etc.\nFor example, next expression creates a new array from 0 to 9 and then filters it by even numbers:\n\n```expr\nfilter(0..9, {# % 2 == 0})\n```\n\nIf items of the array is a struct or a map, it is possible to access fields with\nomitted `#` symbol (`#.Value` becomes `.Value`).\n\n```expr\nfilter(tweets, {len(.Content) > 240})\n```\n\nBraces `{` `}` can be omitted:\n\n```expr\nfilter(tweets, len(.Content) > 240)\n```\n\n:::tip\nIn nested predicates, to access the outer variable, use [variables](#variables).\n\n```expr\nfilter(posts, {\n let post = #; \n any(.Comments, .Author == post.Author)\n}) \n```\n\n:::\n\n## String Functions\n\n### trim(str[, chars]) {#trim}\n\nRemoves white spaces from both ends of a string `str`.\nIf the optional `chars` argument is given, it is a string specifying the set of characters to be removed.\n\n```expr\ntrim(\" Hello \") == \"Hello\"\ntrim(\"__Hello__\", \"_\") == \"Hello\"\n```\n\n### trimPrefix(str, prefix) {#trimPrefix}\n\nRemoves the specified prefix from the string `str` if it starts with that prefix.\n\n```expr\ntrimPrefix(\"HelloWorld\", \"Hello\") == \"World\"\n```\n\n### trimSuffix(str, suffix) {#trimSuffix}\n\nRemoves the specified suffix from the string `str` if it ends with that suffix.\n\n```expr\ntrimSuffix(\"HelloWorld\", \"World\") == \"Hello\"\n```\n\n### upper(str) {#upper}\n\nConverts all the characters in string `str` to uppercase.\n\n```expr\nupper(\"hello\") == \"HELLO\"\n```\n\n### lower(str) {#lower}\n\nConverts all the characters in string `str` to lowercase.\n\n```expr\nlower(\"HELLO\") == \"hello\"\n```\n\n### split(str, delimiter[, n]) {#split}\n\nSplits the string `str` at each instance of the delimiter and returns an array of substrings.\n\n```expr\nsplit(\"apple,orange,grape\", \",\") == [\"apple\", \"orange\", \"grape\"]\nsplit(\"apple,orange,grape\", \",\", 2) == [\"apple\", \"orange,grape\"]\n```\n\n### splitAfter(str, delimiter[, n]) {#splitAfter}\n\nSplits the string `str` after each instance of the delimiter.\n\n```expr\nsplitAfter(\"apple,orange,grape\", \",\") == [\"apple,\", \"orange,\", \"grape\"]\nsplitAfter(\"apple,orange,grape\", \",\", 2) == [\"apple,\", \"orange,grape\"]\n```\n\n### replace(str, old, new) {#replace}\n\nReplaces all occurrences of `old` in string `str` with `new`.\n\n```expr\nreplace(\"Hello World\", \"World\", \"Universe\") == \"Hello Universe\"\n```\n\n### repeat(str, n) {#repeat}\n\nRepeats the string `str` `n` times.\n\n```expr\nrepeat(\"Hi\", 3) == \"HiHiHi\"\n```\n\n### indexOf(str, substring) {#indexOf}\n\nReturns the index of the first occurrence of the substring in string `str` or -1 if not found.\n\n```expr\nindexOf(\"apple pie\", \"pie\") == 6\n```\n\n### lastIndexOf(str, substring) {#lastIndexOf}\n\nReturns the index of the last occurrence of the substring in string `str` or -1 if not found.\n\n```expr\nlastIndexOf(\"apple pie apple\", \"apple\") == 10\n```\n\n### hasPrefix(str, prefix) {#hasPrefix}\n\nReturns `true` if string `str` starts with the given prefix.\n\n```expr\nhasPrefix(\"HelloWorld\", \"Hello\") == true\n```\n\n### hasSuffix(str, suffix) {#hasSuffix}\n\nReturns `true` if string `str` ends with the given suffix.\n\n```expr\nhasSuffix(\"HelloWorld\", \"World\") == true\n```\n\n## Date Functions\n\nExpr has a built-in support for Go's [time package](https://pkg.go.dev/time).\nIt is possible to subtract two dates and get the duration between them:\n\n```expr\ncreatedAt - now()\n```\n\nIt is possible to add a duration to a date:\n\n```expr\ncreatedAt + duration(\"1h\")\n```\n\nAnd it is possible to compare dates:\n\n```expr\ncreatedAt > now() - duration(\"1h\")\n```\n\n### now() {#now}\n\nReturns the current date as a [time.Time](https://pkg.go.dev/time#Time) value.\n\n```expr\nnow().Year() == 2024\n```\n\n### duration(str) {#duration}\n\nReturns [time.Duration](https://pkg.go.dev/time#Duration) value of the given string `str`.\n\nValid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".\n\n```expr\nduration(\"1h\").Seconds() == 3600\n```\n\n### date(str[, format[, timezone]]) {#date}\n\nConverts the given string `str` into a date representation.\n\nIf the optional `format` argument is given, it is a string specifying the format of the date.\nThe format string uses the same formatting rules as the standard\nGo [time package](https://pkg.go.dev/time#pkg-constants).\n\nIf the optional `timezone` argument is given, it is a string specifying the timezone of the date.\n\nIf the `format` argument is not given, the `v` argument must be in one of the following formats:\n\n- 2006-01-02\n- 15:04:05\n- 2006-01-02 15:04:05\n- RFC3339\n- RFC822,\n- RFC850,\n- RFC1123,\n\n```expr\ndate(\"2023-08-14\")\ndate(\"15:04:05\")\ndate(\"2023-08-14T00:00:00Z\")\ndate(\"2023-08-14 00:00:00\", \"2006-01-02 15:04:05\", \"Europe/Zurich\")\n```\n\nAvailable methods on the date:\n\n- `Year()` - returns the year \n- `Month()` - returns the month (starting from 1)\n- `Day()` - returns the day of the month\n- `Hour()` - returns the hour\n- `Minute()` - returns the minute\n- `Second()` - returns the second\n- `Weekday()` - returns the day of the week\n- `YearDay()` - returns the day of the year\n- and [more](https://pkg.go.dev/time#Time).\n\n```expr\ndate(\"2023-08-14\").Year() == 2023\n```\n\n### timezone(str) {#timezone}\n\nReturns the timezone of the given string `str`. List of available timezones can be\nfound [here](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).\n\n```expr\ntimezone(\"Europe/Zurich\")\ntimezone(\"UTC\")\n```\n\nTo convert a date to a different timezone, use the [`In()`](https://pkg.go.dev/time#Time.In) method:\n\n```expr\ndate(\"2023-08-14 00:00:00\").In(timezone(\"Europe/Zurich\"))\n```\n\n## Number Functions\n\n### max(n1, n2) {#max}\n\nReturns the maximum of the two numbers `n1` and `n2`.\n\n```expr\nmax(5, 7) == 7\n```\n\n### min(n1, n2) {#min}\n\nReturns the minimum of the two numbers `n1` and `n2`.\n\n```expr\nmin(5, 7) == 5\n```\n\n### abs(n) {#abs}\n\nReturns the absolute value of a number.\n\n```expr\nabs(-5) == 5\n```\n\n### ceil(n) {#ceil}\n\nReturns the least integer value greater than or equal to x.\n\n```expr\nceil(1.5) == 2.0\n```\n\n### floor(n) {#floor}\n\nReturns the greatest integer value less than or equal to x.\n\n```expr\nfloor(1.5) == 1.0\n```\n\n### round(n) {#round}\n\nReturns the nearest integer, rounding half away from zero.\n\n```expr\nround(1.5) == 2.0\n```\n\n## Array Functions\n\n### all(array, predicate) {#all}\n\nReturns **true** if all elements satisfies the [predicate](#predicate).\nIf the array is empty, returns **true**.\n\n```expr\nall(tweets, {.Size < 280})\n```\n\n### any(array, predicate) {#any}\n\nReturns **true** if any elements satisfies the [predicate](#predicate).\nIf the array is empty, returns **false**.\n\n```expr\nany(tweets, {.Size > 280})\n```\n\n### one(array, predicate) {#one}\n\nReturns **true** if _exactly one_ element satisfies the [predicate](#predicate).\nIf the array is empty, returns **false**.\n\n```expr\none(participants, {.Winner})\n```\n\n### none(array, predicate) {#none}\n\nReturns **true** if _all elements does not_ satisfy the [predicate](#predicate).\nIf the array is empty, returns **true**.\n\n```expr\nnone(tweets, {.Size > 280})\n```\n\n### map(array, predicate) {#map}\n\nReturns new array by applying the [predicate](#predicate) to each element of\nthe array.\n\n```expr\nmap(tweets, {.Size})\n```\n\n### filter(array, predicate) {#filter}\n\nReturns new array by filtering elements of the array by [predicate](#predicate).\n\n```expr\nfilter(users, .Name startsWith \"J\")\n```\n\n### find(array, predicate) {#find}\n\nFinds the first element in an array that satisfies the [predicate](#predicate).\n\n```expr\nfind([1, 2, 3, 4], # > 2) == 3\n```\n\n### findIndex(array, predicate) {#findIndex}\n\nFinds the index of the first element in an array that satisfies the [predicate](#predicate).\n\n```expr\nfindIndex([1, 2, 3, 4], # > 2) == 2\n```\n\n### findLast(array, predicate) {#findLast}\n\nFinds the last element in an array that satisfies the [predicate](#predicate).\n\n```expr\nfindLast([1, 2, 3, 4], # > 2) == 4\n```\n\n### findLastIndex(array, predicate) {#findLastIndex}\n\nFinds the index of the last element in an array that satisfies the [predicate](#predicate).\n\n```expr\nfindLastIndex([1, 2, 3, 4], # > 2) == 3\n```\n\n### groupBy(array, predicate) {#groupBy}\n\nGroups the elements of an array by the result of the [predicate](#predicate).\n\n```expr\ngroupBy(users, .Age)\n```\n\n### count(array[, predicate]) {#count}\n\nReturns the number of elements what satisfies the [predicate](#predicate).\n\n```expr\ncount(users, .Age > 18)\n```\n\nEquivalent to:\n\n```expr\nlen(filter(users, .Age > 18))\n```\n\nIf the predicate is not given, returns the number of `true` elements in the array.\n\n```expr\ncount([true, false, true]) == 2\n```\n\n### concat(array1, array2[, ...]) {#concat}\n\nConcatenates two or more arrays.\n\n```expr\nconcat([1, 2], [3, 4]) == [1, 2, 3, 4]\n```\n\n### flatten(array) {#flatten}\n\nFlattens given array into one-dimensional array.\n\n```expr\nflatten([1, 2, [3, 4]]) == [1, 2, 3, 4]\n```\n\n### uniq(array) {#uniq}\n\nRemoves duplicates from an array.\n\n```expr\nuniq([1, 2, 3, 2, 1]) == [1, 2, 3]\n```\n\n### join(array[, delimiter]) {#join}\n\nJoins an array of strings into a single string with the given delimiter.\nIf no delimiter is given, an empty string is used.\n\n```expr\njoin([\"apple\", \"orange\", \"grape\"], \",\") == \"apple,orange,grape\"\njoin([\"apple\", \"orange\", \"grape\"]) == \"appleorangegrape\"\n```\n\n### reduce(array, predicate[, initialValue]) {#reduce}\n\nApplies a predicate to each element in the array, reducing the array to a single value.\nOptional `initialValue` argument can be used to specify the initial value of the accumulator.\nIf `initialValue` is not given, the first element of the array is used as the initial value.\n\nFollowing variables are available in the predicate:\n\n- `#` - the current element\n- `#acc` - the accumulator\n- `#index` - the index of the current element\n\n```expr\nreduce(1..9, #acc + #)\nreduce(1..9, #acc + #, 0)\n```\n\n### sum(array[, predicate]) {#sum}\n\nReturns the sum of all numbers in the array.\n\n```expr\nsum([1, 2, 3]) == 6\n```\n\nIf the optional `predicate` argument is given, it is a predicate that is applied on each element\nof the array before summing.\n\n```expr\nsum(accounts, .Balance)\n```\n\nEquivalent to:\n\n```expr\nreduce(accounts, #acc + .Balance, 0)\n// or\nsum(map(accounts, .Balance))\n```\n\n### mean(array) {#mean}\n\nReturns the average of all numbers in the array.\n\n```expr\nmean([1, 2, 3]) == 2.0\n```\n\n### median(array) {#median}\n\nReturns the median of all numbers in the array.\n\n```expr\nmedian([1, 2, 3]) == 2.0\n```\n\n### first(array) {#first}\n\nReturns the first element from an array. If the array is empty, returns `nil`.\n\n```expr\nfirst([1, 2, 3]) == 1\n```\n\n### last(array) {#last}\n\nReturns the last element from an array. If the array is empty, returns `nil`.\n\n```expr\nlast([1, 2, 3]) == 3\n```\n\n### take(array, n) {#take}\n\nReturns the first `n` elements from an array. If the array has fewer than `n` elements, returns the whole array.\n\n```expr\ntake([1, 2, 3, 4], 2) == [1, 2]\n```\n\n### reverse(array) {#reverse}\n\nReturn new reversed copy of the array.\n\n```expr\nreverse([3, 1, 4]) == [4, 1, 3]\nreverse(reverse([3, 1, 4])) == [3, 1, 4]\n```\n\n### sort(array[, order]) {#sort}\n\nSorts an array in ascending order. Optional `order` argument can be used to specify the order of sorting: `asc`\nor `desc`.\n\n```expr\nsort([3, 1, 4]) == [1, 3, 4]\nsort([3, 1, 4], \"desc\") == [4, 3, 1]\n```\n\n### sortBy(array[, predicate, order]) {#sortBy}\n\nSorts an array by the result of the [predicate](#predicate). Optional `order` argument can be used to specify the order\nof sorting: `asc` or `desc`.\n\n```expr\nsortBy(users, .Age)\nsortBy(users, .Age, \"desc\")\n```\n\n## Map Functions\n\n### keys(map) {#keys}\n\nReturns an array containing the keys of the map.\n\n```expr\nkeys({\"name\": \"John\", \"age\": 30}) == [\"name\", \"age\"]\n```\n\n### values(map) {#values}\n\nReturns an array containing the values of the map.\n\n```expr\nvalues({\"name\": \"John\", \"age\": 30}) == [\"John\", 30]\n```\n\n## Type Conversion Functions\n\n### type(v) {#type}\n\nReturns the type of the given value `v`.\n\nReturns on of the following types:\n\n- `nil`\n- `bool`\n- `int`\n- `uint`\n- `float`\n- `string`\n- `array`\n- `map`.\n\nFor named types and structs, the type name is returned.\n\n```expr\ntype(42) == \"int\"\ntype(\"hello\") == \"string\"\ntype(now()) == \"time.Time\"\n```\n\n### int(v) {#int}\n\nReturns the integer value of a number or a string.\n\n```expr\nint(\"123\") == 123\n```\n\n### float(v) {#float}\n\nReturns the float value of a number or a string.\n\n```expr\nfloat(\"123.45\") == 123.45\n```\n\n### string(v) {#string}\n\nConverts the given value `v` into a string representation.\n\n```expr\nstring(123) == \"123\"\n```\n\n### toJSON(v) {#toJSON}\n\nConverts the given value `v` to its JSON string representation.\n\n```expr\ntoJSON({\"name\": \"John\", \"age\": 30})\n```\n\n### fromJSON(v) {#fromJSON}\n\nParses the given JSON string `v` and returns the corresponding value.\n\n```expr\nfromJSON('{\"name\": \"John\", \"age\": 30}')\n```\n\n### toBase64(v) {#toBase64}\n\nEncodes the string `v` into Base64 format.\n\n```expr\ntoBase64(\"Hello World\") == \"SGVsbG8gV29ybGQ=\"\n```\n\n### fromBase64(v) {#fromBase64}\n\nDecodes the Base64 encoded string `v` back to its original form.\n\n```expr\nfromBase64(\"SGVsbG8gV29ybGQ=\") == \"Hello World\"\n```\n\n### toPairs(map) {#toPairs}\n\nConverts a map to an array of key-value pairs.\n\n```expr\ntoPairs({\"name\": \"John\", \"age\": 30}) == [[\"name\", \"John\"], [\"age\", 30]]\n```\n\n### fromPairs(array) {#fromPairs}\n\nConverts an array of key-value pairs to a map.\n\n```expr\nfromPairs([[\"name\", \"John\"], [\"age\", 30]]) == {\"name\": \"John\", \"age\": 30}\n```\n\n## Miscellaneous Functions\n\n### len(v) {#len}\n\nReturns the length of an array, a map or a string.\n\n```expr\nlen([1, 2, 3]) == 3\nlen({\"name\": \"John\", \"age\": 30}) == 2\nlen(\"Hello\") == 5\n```\n\n### get(v, index) {#get}\n\nRetrieves the element at the specified index from an array or map `v`. If the index is out of range, returns `nil`.\nOr the key does not exist, returns `nil`.\n\n```expr\nget([1, 2, 3], 1) == 2\nget({\"name\": \"John\", \"age\": 30}, \"name\") == \"John\"\n```\n\n## Bitwise Functions\n\n### bitand(int, int) {#bitand}\n\nReturns the values resulting from the bitwise AND operation.\n\n```expr\nbitand(0b1010, 0b1100) == 0b1000\n```\n\n### bitor(int, int) {#bitor}\n\nReturns the values resulting from the bitwise OR operation.\n\n```expr\nbitor(0b1010, 0b1100) == 0b1110\n```\n\n### bitxor(int, int) {#bitxor}\n\nReturns the values resulting from the bitwise XOR operation.\n\n```expr\nbitxor(0b1010, 0b1100) == 0b110\n```\n\n### bitnand(int, int) {#bitnand}\n\nReturns the values resulting from the bitwise AND NOT operation.\n\n```expr\nbitnand(0b1010, 0b1100) == 0b10\n```\n\n### bitnot(int) {#bitnot}\n\nReturns the values resulting from the bitwise NOT operation.\n\n```expr\nbitnot(0b1010) == -0b1011\n```\n\n### bitshl(int, int) {#bitshl}\n\nReturns the values resulting from the Left Shift operation.\n\n```expr\nbitshl(0b101101, 2) == 0b10110100\n```\n\n### bitshr(int, int) {#bitshr}\n\nReturns the values resulting from the Right Shift operation.\n\n```expr\nbitshr(0b101101, 2) == 0b1011\n```\n\n### bitushr(int, int) {#bitushr}\n\nReturns the values resulting from the unsigned Right Shift operation.\n\n```expr\nbitushr(-0b101, 2) == 4611686018427387902\n```\n"
},
{
"path": "docs/patch.md",
"content": "# Patch\n\nSometimes it may be necessary to modify an expression before the compilation.\nFor example, you may want to replace a variable with a constant, transform an expression into a function call, \nor even modify the expression to use a different operator.\n\n## Simple example\n\nLet's start with a simple example. We have an expression that uses a variable `foo`:\n\n```go\nprogram, err := expr.Compile(`foo + bar`)\n```\n\nWe want to replace the `foo` variable with a constant `42`. First, we need to implement a [visitor](./visitor.md):\n\n```go\ntype FooPatcher struct{}\n\nfunc (FooPatcher) Visit(node *ast.Node) {\n if n, ok := (*node).(*ast.IdentifierNode); ok && n.Value == \"foo\" {\n // highlight-next-line\n ast.Patch(node, &ast.IntegerNode{Value: 42})\n }\n}\n```\n\nWe used the [ast.Patch](https://pkg.go.dev/github.com/expr-lang/expr/ast#Patch) function to replace the `foo` variable with an integer node.\n\nNow we can use the `FooPatcher` to modify the expression on compilation via the [expr.Patch](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option:\n\n```go\nprogram, err := expr.Compile(`foo + bar`, expr.Patch(FooPatcher{}))\n```\n\n## Advanced example\n\nLet's consider a more complex example. We have an expression that uses variables `foo` and `bar` of type `Decimal`:\n\n```go\ntype Decimal struct {\n Value int\n}\n```\n\nAnd we want to transform the following expression:\n\n```expr\na + b + c\n```\n\nInto functions calls that accept `Decimal` arguments:\n\n```expr\nadd(add(a, b), c)\n```\n\nFirst, we need to implement a visitor that will transform the expression:\n\n```go\ntype DecimalPatcher struct{}\n\nvar decimalType = reflect.TypeOf(Decimal{})\n\nfunc (DecimalPatcher) Visit(node *ast.Node) {\n if n, ok := (*node).(*ast.BinaryNode); ok && n.Operator == \"+\" {\n \n if !n.Left.Type().AssignableTo(decimalType) {\n return // skip, left side is not a Decimal\n }\n\t\t\n if !n.Right.Type().AssignableTo(decimalType) {\n return // skip, right side is not a Decimal\n }\n\t\t\n // highlight-start\n callNode := &ast.CallNode{\n Callee: &ast.IdentifierNode{Value: \"add\"},\n Arguments: []ast.Node{n.Left, n.Right},\n }\n ast.Patch(node, callNode)\n // highlight-end\n\t\t\n (*node).SetType(decimalType) // set the type, so the patcher can be applied recursively\n }\n}\n```\n\nWe used [Type()](https://pkg.go.dev/github.com/expr-lang/expr/ast#Node.Type) method to get the type of the expression node.\nThe `AssignableTo` method is used to check if the type is `Decimal`. If both sides are `Decimal`, we replace the expression with a function call.\n\nThe important part of this patcher is to set correct types for the nodes. As we constructed a new `CallNode`, it lacks the type information.\nSo after the first patcher run, if we want the patcher to be applied recursively, we need to set the type of the node.\n\n\nNow we can use the `DecimalPatcher` to modify the expression:\n\n```go\nenv := map[string]interface{}{\n \"a\": Decimal{1},\n \"b\": Decimal{2},\n \"c\": Decimal{3},\n \"add\": func(x, y Decimal) Decimal {\n return Decimal{x.Value + y.Value}\n },\n}\n\ncode := `a + b + c`\n\n// highlight-next-line\nprogram, err := expr.Compile(code, expr.Env(env), expr.Patch(DecimalPatcher{}))\nif err != nil {\n panic(err)\n}\n\noutput, err := expr.Run(program, env)\nif err != nil {\n panic(err)\n}\n\nfmt.Println(output) // Decimal{6}\n```\n\n\n:::info\nExpr comes with already implemented patcher that simplifies operator overloading.\n\nThe `DecimalPatcher` can be replaced with the [Operator](https://pkg.go.dev/github.com/expr-lang/expr#Operator) option.\n\n```go\nprogram, err := expr.Compile(code, expr.Env(env), expr.Operator(\"+\", \"add\"))\n```\n\nOperator overloading patcher will check if provided functions (`\"add\"`) satisfy the operator (`\"+\"`), and\nreplace the operator with the function call.\n:::\n"
},
{
"path": "docs/visitor.md",
"content": "# Visitor\n\nExpr provides an interface to traverse the AST of the expression before the compilation.\nThe `Visitor` interface allows you to collect information about the expression, modify the expression, or even generate\na new expression.\n\nLet's start with an [ast.Visitor](https://pkg.go.dev/github.com/expr-lang/expr/ast#Visitor) implementation which will \ncollect all variables used in the expression.\n\nVisitor must implement a single method `Visit(*ast.Node)`, which will be called for each node in the AST.\n\n```go\ntype Visitor struct {\n Identifiers []string\n}\n\nfunc (v *Visitor) Visit(node *ast.Node) {\n if n, ok := (*node).(*ast.IdentifierNode); ok {\n v.Identifiers = append(v.Identifiers, n.Value)\n }\n}\n```\n\nFull list of available AST nodes can be found in the [ast](https://pkg.go.dev/github.com/expr-lang/expr/ast) documentation.\n\nLet's parse the expression and use [ast.Walk](https://pkg.go.dev/github.com/expr-lang/expr/ast#Walk) to traverse the AST:\n\n```go\ntree, err := parser.Parse(`foo + bar`)\nif err != nil {\n panic(err)\n}\n\nv := &Visitor{}\n// highlight-next-line\nast.Walk(&tree.Node, v)\n\nfmt.Println(v.Identifiers) // [foo, bar]\n```\n\n:::note\n\nAlthough it is possible to access the AST of compiled program, it may be already be modified by patchers, optimizers, etc.\n\n```go\nprogram, err := expr.Compile(`foo + bar`)\nif err != nil {\n panic(err)\n}\n\n// highlight-next-line\nnode := program.Node()\n\nv := &Visitor{}\nast.Walk(&node, v)\n```\n\n:::\n"
},
{
"path": "expr.go",
"content": "package expr\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"time\"\n\n\t\"github.com/expr-lang/expr/ast\"\n\t\"github.com/expr-lang/expr/builtin\"\n\t\"github.com/expr-lang/expr/checker\"\n\t\"github.com/expr-lang/expr/compiler\"\n\t\"github.com/expr-lang/expr/conf\"\n\t\"github.com/expr-lang/expr/file\"\n\t\"github.com/expr-lang/expr/optimizer\"\n\t\"github.com/expr-lang/expr/parser\"\n\t\"github.com/expr-lang/expr/patcher\"\n\t\"github.com/expr-lang/expr/vm\"\n)\n\n// Option for configuring config.\ntype Option func(c *conf.Config)\n\n// Env specifies expected input of env for type checks.\n// If struct is passed, all fields will be treated as variables,\n// as well as all fields of embedded structs and struct itself.\n// If map is passed, all items will be treated as variables.\n// Methods defined on this type will be available as functions.\nfunc Env(env any) Option {\n\treturn func(c *conf.Config) {\n\t\tc.WithEnv(env)\n\t}\n}\n\n// AllowUndefinedVariables allows to use undefined variables inside expressions.\n// This can be used with expr.Env option to partially define a few variables.\nfunc AllowUndefinedVariables() Option {\n\treturn func(c *conf.Config) {\n\t\tc.Strict = false\n\t}\n}\n\n// Operator allows to replace a binary operator with a function.\nfunc Operator(operator string, fn ...string) Option {\n\treturn func(c *conf.Config) {\n\t\tp := &patcher.OperatorOverloading{\n\t\t\tOperator: operator,\n\t\t\tOverloads: fn,\n\t\t\tEnv: &c.Env,\n\t\t\tFunctions: c.Functions,\n\t\t\tNtCache: &c.NtCache,\n\t\t}\n\t\tc.Visitors = append(c.Visitors, p)\n\t}\n}\n\n// ConstExpr defines func expression as constant. If all argument to this function is constants,\n// then it can be replaced by result of this func call on compile step.\nfunc ConstExpr(fn string) Option {\n\treturn func(c *conf.Config) {\n\t\tc.ConstExpr(fn)\n\t}\n}\n\n// AsAny tells the compiler to expect any result.\nfunc AsAny() Option {\n\treturn func(c *conf.Config) {\n\t\tc.ExpectAny = true\n\t}\n}\n\n// AsKind tells the compiler to expect kind of the result.\nfunc AsKind(kind reflect.Kind) Option {\n\treturn func(c *conf.Config) {\n\t\tc.Expect = kind\n\t\tc.ExpectAny = true\n\t}\n}\n\n// AsBool tells the compiler to expect a boolean result.\nfunc AsBool() Option {\n\treturn func(c *conf.Config) {\n\t\tc.Expect = reflect.Bool\n\t\tc.ExpectAny = true\n\t}\n}\n\n// AsInt tells the compiler to expect an int result.\nfunc AsInt() Option {\n\treturn func(c *conf.Config) {\n\t\tc.Expect = reflect.Int\n\t\tc.ExpectAny = true\n\t}\n}\n\n// AsInt64 tells the compiler to expect an int64 result.\nfunc AsInt64() Option {\n\treturn func(c *conf.Config) {\n\t\tc.Expect = reflect.Int64\n\t\tc.ExpectAny = true\n\t}\n}\n\n// AsFloat64 tells the compiler to expect a float64 result.\nfunc AsFloat64() Option {\n\treturn func(c *conf.Config) {\n\t\tc.Expect = reflect.Float64\n\t\tc.ExpectAny = true\n\t}\n}\n\n// DisableIfOperator disables the `if ... else ...` operator syntax so a custom\n// function named `if(...)` can be used without conflicts.\nfunc DisableIfOperator() Option {\n\treturn func(c *conf.Config) {\n\t\tc.DisableIfOperator = true\n\t}\n}\n\n// WarnOnAny tells the compiler to warn if expression return any type.\nfunc WarnOnAny() Option {\n\treturn func(c *conf.Config) {\n\t\tif c.Expect == reflect.Invalid {\n\t\t\tpanic(\"WarnOnAny() works only with combination with AsInt(), AsBool(), etc. options\")\n\t\t}\n\t\tc.ExpectAny = false\n\t}\n}\n\n// Optimize turns optimizations on or off.\nfunc Optimize(b bool) Option {\n\treturn func(c *conf.Config) {\n\t\tc.Optimize = b\n\t}\n}\n\n// DisableShortCircuit turns short circuit off.\nfunc DisableShortCircuit() Option {\n\treturn func(c *conf.Config) {\n\t\tc.ShortCircuit = false\n\t}\n}\n\n// Patch adds visitor to list of visitors what will be applied before compiling AST to bytecode.\nfunc Patch(visitor ast.Visitor) Option {\n\treturn func(c *conf.Config) {\n\t\tc.Visitors = append(c.Visitors, visitor)\n\t}\n}\n\n// Function adds function to list of functions what will be available in expressions.\nfunc Function(name string, fn func(params ...any) (any, error), types ...any) Option {\n\treturn func(c *conf.Config) {\n\t\tts := make([]reflect.Type, len(types))\n\t\tfor i, t := range types {\n\t\t\tt := reflect.TypeOf(t)\n\t\t\tif t.Kind() == reflect.Ptr {\n\t\t\t\tt = t.Elem()\n\t\t\t}\n\t\t\tif t.Kind() != reflect.Func {\n\t\t\t\tpanic(fmt.Sprintf(\"expr: type of %s is not a function\", name))\n\t\t\t}\n\t\t\tts[i] = t\n\t\t}\n\t\tc.Functions[name] = &builtin.Function{\n\t\t\tName: name,\n\t\t\tFunc: fn,\n\t\t\tTypes: ts,\n\t\t}\n\t}\n}\n\n// DisableAllBuiltins disables all builtins.\nfunc DisableAllBuiltins() Option {\n\treturn func(c *conf.Config) {\n\t\tfor name := range c.Builtins {\n\t\t\tc.Disabled[name] = true\n\t\t}\n\t}\n}\n\n// DisableBuiltin disables builtin function.\nfunc DisableBuiltin(name string) Option {\n\treturn func(c *conf.Config) {\n\t\tc.Disabled[name] = true\n\t}\n}\n\n// EnableBuiltin enables builtin function.\nfunc EnableBuiltin(name string) Option {\n\treturn func(c *conf.Config) {\n\t\tdelete(c.Disabled, name)\n\t}\n}\n\n// WithContext passes context to all functions calls with a context.Context argument.\nfunc WithContext(name string) Option {\n\treturn func(c *conf.Config) {\n\t\tc.Visitors = append(c.Visitors, patcher.WithContext{\n\t\t\tName: name,\n\t\t\tFunctions: c.Functions,\n\t\t\tEnv: &c.Env,\n\t\t\tNtCache: &c.NtCache,\n\t\t})\n\t}\n}\n\n// Timezone sets default timezone for date() and now() builtin functions.\nfunc Timezone(name string) Option {\n\ttz, err := time.LoadLocation(name)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn Patch(patcher.WithTimezone{\n\t\tLocation: tz,\n\t})\n}\n\n// MaxNodes sets the maximum number of nodes allowed in the expression.\n// By default, the maximum number of nodes is conf.DefaultMaxNodes.\n// If MaxNodes is set to 0, the node budget check is disabled.\nfunc MaxNodes(n uint) Option {\n\treturn func(c *conf.Config) {\n\t\tc.MaxNodes = n\n\t}\n}\n\n// Compile parses and compiles given input expression to bytecode program.\nfunc Compile(input string, ops ...Option) (*vm.Program, error) {\n\tconfig := conf.CreateNew()\n\tfor _, op := range ops {\n\t\top(config)\n\t}\n\tfor name := range config.Disabled {\n\t\tdelete(config.Builtins, name)\n\t}\n\tconfig.Check()\n\n\ttree, err := checker.ParseCheck(input, config)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tif config.Optimize {\n\t\terr = optimizer.Optimize(&tree.Node, config)\n\t\tif err != nil {\n\t\t\tvar fileError *file.Error\n\t\t\tif errors.As(err, &fileError) {\n\t\t\t\treturn nil, fileError.Bind(tree.Source)\n\t\t\t}\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tprogram, err := compiler.Compile(tree, config)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn program, nil\n}\n\n// Run evaluates given bytecode program.\nfunc Run(program *vm.Program, env any) (any, error) {\n\treturn vm.Run(program, env)\n}\n\n// Eval parses, compiles and runs given input.\nfunc Eval(input string, env any) (any, error) {\n\tif _, ok := env.(Option); ok {\n\t\treturn nil, fmt.Errorf(\"misused expr.Eval: second argument (env) should be passed without expr.Env\")\n\t}\n\n\ttree, err := parser.Parse(input)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tprogram, err := compiler.Compile(tree, nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\toutput, err := Run(program, env)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn output, nil\n}\n"
},
{
"path": "expr_test.go",
"content": "package expr_test\n\nimport (\n\t\"context\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"os\"\n\t\"reflect\"\n\t\"strings\"\n\t\"sync\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/expr-lang/expr/conf\"\n\t\"github.com/expr-lang/expr/internal/testify/assert\"\n\t\"github.com/expr-lang/expr/internal/testify/require\"\n\t\"github.com/expr-lang/expr/types\"\n\t\"github.com/expr-lang/expr/vm\"\n\n\t\"github.com/expr-lang/expr\"\n\t\"github.com/expr-lang/expr/ast\"\n\t\"github.com/expr-lang/expr/file\"\n\t\"github.com/expr-lang/expr/test/mock\"\n)\n\nfunc ExampleEval() {\n\toutput, err := expr.Eval(\"greet + name\", map[string]any{\n\t\t\"greet\": \"Hello, \",\n\t\t\"name\": \"world!\",\n\t})\n\tif err != nil {\n\t\tfmt.Printf(\"err: %v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: Hello, world!\n}\n\nfunc ExampleEval_runtime_error() {\n\t_, err := expr.Eval(`map(1..3, {1 % (# - 3)})`, nil)\n\tfmt.Print(err)\n\n\t// Output: runtime error: integer divide by zero (1:14)\n\t// | map(1..3, {1 % (# - 3)})\n\t// | .............^\n}\n\nfunc ExampleCompile() {\n\tenv := map[string]any{\n\t\t\"foo\": 1,\n\t\t\"bar\": 99,\n\t}\n\n\tprogram, err := expr.Compile(\"foo in 1..99 and bar in 1..99\", expr.Env(env))\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: true\n}\n\nfunc ExampleEval_bytes_literal() {\n\t// Bytes literal returns []byte.\n\toutput, err := expr.Eval(`b\"abc\"`, nil)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: [97 98 99]\n}\n\nfunc TestDisableIfOperator_AllowsIfFunction(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"if\": func(x int) int { return x + 1 },\n\t}\n\tprogram, err := expr.Compile(\"if(41)\", expr.Env(env), expr.DisableIfOperator())\n\trequire.NoError(t, err)\n\tout, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, 42, out)\n}\n\nfunc ExampleEnv() {\n\ttype Segment struct {\n\t\tOrigin string\n\t}\n\ttype Passengers struct {\n\t\tAdults int\n\t}\n\ttype Meta struct {\n\t\tTags map[string]string\n\t}\n\ttype Env struct {\n\t\tMeta\n\t\tSegments []*Segment\n\t\tPassengers *Passengers\n\t\tMarker string\n\t}\n\n\tcode := `all(Segments, {.Origin == \"MOW\"}) && Passengers.Adults > 0 && Tags[\"foo\"] startsWith \"bar\"`\n\n\tprogram, err := expr.Compile(code, expr.Env(Env{}))\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tenv := Env{\n\t\tMeta: Meta{\n\t\t\tTags: map[string]string{\n\t\t\t\t\"foo\": \"bar\",\n\t\t\t},\n\t\t},\n\t\tSegments: []*Segment{\n\t\t\t{Origin: \"MOW\"},\n\t\t},\n\t\tPassengers: &Passengers{\n\t\t\tAdults: 2,\n\t\t},\n\t\tMarker: \"test\",\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: true\n}\n\nfunc ExampleEnv_tagged_field_names() {\n\tenv := struct {\n\t\tFirstWord string\n\t\tSeparator string `expr:\"Space\"`\n\t\tSecondWord string `expr:\"second_word\"`\n\t}{\n\t\tFirstWord: \"Hello\",\n\t\tSeparator: \" \",\n\t\tSecondWord: \"World\",\n\t}\n\n\toutput, err := expr.Eval(`FirstWord + Space + second_word`, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: Hello World\n}\n\nfunc ExampleEnv_hidden_tagged_field_names() {\n\ttype Internal struct {\n\t\tVisible string\n\t\tHidden string `expr:\"-\"`\n\t}\n\ttype environment struct {\n\t\tVisible string\n\t\tHidden string `expr:\"-\"`\n\t\tHiddenInternal Internal `expr:\"-\"`\n\t\tVisibleInternal Internal\n\t}\n\n\tenv := environment{\n\t\tHidden: \"First level secret\",\n\t\tHiddenInternal: Internal{\n\t\t\tVisible: \"Second level secret\",\n\t\t\tHidden: \"Also hidden\",\n\t\t},\n\t\tVisibleInternal: Internal{\n\t\t\tVisible: \"Not a secret\",\n\t\t\tHidden: \"Hidden too\",\n\t\t},\n\t}\n\n\thiddenValues := []string{\n\t\t`Hidden`,\n\t\t`HiddenInternal`,\n\t\t`HiddenInternal.Visible`,\n\t\t`HiddenInternal.Hidden`,\n\t\t`VisibleInternal[\"Hidden\"]`,\n\t}\n\tfor _, expression := range hiddenValues {\n\t\toutput, err := expr.Eval(expression, env)\n\t\tif err == nil || !strings.Contains(err.Error(), \"cannot fetch\") {\n\t\t\tfmt.Printf(\"unexpected output: %v; err: %v\\n\", output, err)\n\t\t\treturn\n\t\t}\n\t\tfmt.Printf(\"%q is hidden as expected\\n\", expression)\n\t}\n\n\tvisibleValues := []string{\n\t\t`Visible`,\n\t\t`VisibleInternal`,\n\t\t`VisibleInternal[\"Visible\"]`,\n\t}\n\tfor _, expression := range visibleValues {\n\t\t_, err := expr.Eval(expression, env)\n\t\tif err != nil {\n\t\t\tfmt.Printf(\"unexpected error: %v\\n\", err)\n\t\t\treturn\n\t\t}\n\t\tfmt.Printf(\"%q is visible as expected\\n\", expression)\n\t}\n\n\ttestWithIn := []string{\n\t\t`not (\"Hidden\" in $env)`,\n\t\t`\"Visible\" in $env`,\n\t\t`not (\"Hidden\" in VisibleInternal)`,\n\t\t`\"Visible\" in VisibleInternal`,\n\t}\n\tfor _, expression := range testWithIn {\n\t\tval, err := expr.Eval(expression, env)\n\t\tshouldBeTrue, ok := val.(bool)\n\t\tif err != nil || !ok || !shouldBeTrue {\n\t\t\tfmt.Printf(\"unexpected result; value: %v; error: %v\\n\", val, err)\n\t\t\treturn\n\t\t}\n\t}\n\n\t// Output: \"Hidden\" is hidden as expected\n\t// \"HiddenInternal\" is hidden as expected\n\t// \"HiddenInternal.Visible\" is hidden as expected\n\t// \"HiddenInternal.Hidden\" is hidden as expected\n\t// \"VisibleInternal[\\\"Hidden\\\"]\" is hidden as expected\n\t// \"Visible\" is visible as expected\n\t// \"VisibleInternal\" is visible as expected\n\t// \"VisibleInternal[\\\"Visible\\\"]\" is visible as expected\n}\n\nfunc ExampleAsKind() {\n\tprogram, err := expr.Compile(\"{a: 1, b: 2}\", expr.AsKind(reflect.Map))\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, nil)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: map[a:1 b:2]\n}\n\nfunc ExampleAsBool() {\n\tenv := map[string]int{\n\t\t\"foo\": 0,\n\t}\n\n\tprogram, err := expr.Compile(\"foo >= 0\", expr.Env(env), expr.AsBool())\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output.(bool))\n\n\t// Output: true\n}\n\nfunc ExampleAsBool_error() {\n\tenv := map[string]any{\n\t\t\"foo\": 0,\n\t}\n\n\t_, err := expr.Compile(\"foo + 42\", expr.Env(env), expr.AsBool())\n\n\tfmt.Printf(\"%v\", err)\n\n\t// Output: expected bool, but got int\n}\n\nfunc ExampleAsInt() {\n\tprogram, err := expr.Compile(\"42\", expr.AsInt())\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, nil)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%T(%v)\", output, output)\n\n\t// Output: int(42)\n}\n\nfunc ExampleAsInt64() {\n\tenv := map[string]any{\n\t\t\"rating\": 5.5,\n\t}\n\n\tprogram, err := expr.Compile(\"rating\", expr.Env(env), expr.AsInt64())\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output.(int64))\n\n\t// Output: 5\n}\n\nfunc ExampleAsFloat64() {\n\tprogram, err := expr.Compile(\"42\", expr.AsFloat64())\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, nil)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output.(float64))\n\n\t// Output: 42\n}\n\nfunc ExampleAsFloat64_error() {\n\t_, err := expr.Compile(`!!true`, expr.AsFloat64())\n\n\tfmt.Printf(\"%v\", err)\n\n\t// Output: expected float64, but got bool\n}\n\nfunc ExampleWarnOnAny() {\n\t// Arrays always have []any type. The expression return type is any.\n\t// AsInt() instructs compiler to expect int or any, and cast to int,\n\t// if possible. WarnOnAny() instructs to return an error on any type.\n\t_, err := expr.Compile(`[42, true, \"yes\"][0]`, expr.AsInt(), expr.WarnOnAny())\n\n\tfmt.Printf(\"%v\", err)\n\n\t// Output: expected int, but got interface {}\n}\n\nfunc ExampleOperator() {\n\tcode := `\n\t\tNow() > CreatedAt &&\n\t\t(Now() - CreatedAt).Hours() > 24\n\t`\n\n\ttype Env struct {\n\t\tCreatedAt time.Time\n\t\tNow func() time.Time\n\t\tSub func(a, b time.Time) time.Duration\n\t\tAfter func(a, b time.Time) bool\n\t}\n\n\toptions := []expr.Option{\n\t\texpr.Env(Env{}),\n\t\texpr.Operator(\">\", \"After\"),\n\t\texpr.Operator(\"-\", \"Sub\"),\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tenv := Env{\n\t\tCreatedAt: time.Date(2018, 7, 14, 0, 0, 0, 0, time.UTC),\n\t\tNow: func() time.Time { return time.Now() },\n\t\tSub: func(a, b time.Time) time.Duration { return a.Sub(b) },\n\t\tAfter: func(a, b time.Time) bool { return a.After(b) },\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: true\n}\n\nfunc ExampleOperator_with_decimal() {\n\ttype Decimal struct{ N float64 }\n\tcode := `A + B - C`\n\n\ttype Env struct {\n\t\tA, B, C Decimal\n\t\tSub func(a, b Decimal) Decimal\n\t\tAdd func(a, b Decimal) Decimal\n\t}\n\n\toptions := []expr.Option{\n\t\texpr.Env(Env{}),\n\t\texpr.Operator(\"+\", \"Add\"),\n\t\texpr.Operator(\"-\", \"Sub\"),\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"Compile error: %v\", err)\n\t\treturn\n\t}\n\n\tenv := Env{\n\t\tA: Decimal{3},\n\t\tB: Decimal{2},\n\t\tC: Decimal{1},\n\t\tSub: func(a, b Decimal) Decimal { return Decimal{a.N - b.N} },\n\t\tAdd: func(a, b Decimal) Decimal { return Decimal{a.N + b.N} },\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: {4}\n}\n\nfunc fib(n int) int {\n\tif n <= 1 {\n\t\treturn n\n\t}\n\treturn fib(n-1) + fib(n-2)\n}\n\nfunc ExampleConstExpr() {\n\tcode := `[fib(5), fib(3+3), fib(dyn)]`\n\n\tenv := map[string]any{\n\t\t\"fib\": fib,\n\t\t\"dyn\": 0,\n\t}\n\n\toptions := []expr.Option{\n\t\texpr.Env(env),\n\t\texpr.ConstExpr(\"fib\"), // Mark fib func as constant expression.\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\t// Only fib(5) and fib(6) calculated on Compile, fib(dyn) can be called at runtime.\n\tenv[\"dyn\"] = 7\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\\n\", output)\n\n\t// Output: [5 8 13]\n}\n\nfunc ExampleAllowUndefinedVariables() {\n\tcode := `name == nil ? \"Hello, world!\" : sprintf(\"Hello, %v!\", name)`\n\n\tenv := map[string]any{\n\t\t\"sprintf\": fmt.Sprintf,\n\t}\n\n\toptions := []expr.Option{\n\t\texpr.Env(env),\n\t\texpr.AllowUndefinedVariables(), // Allow to use undefined variables.\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\tfmt.Printf(\"%v\\n\", output)\n\n\tenv[\"name\"] = \"you\" // Define variables later on.\n\n\toutput, err = expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\tfmt.Printf(\"%v\\n\", output)\n\n\t// Output: Hello, world!\n\t// Hello, you!\n}\n\nfunc ExampleAllowUndefinedVariables_zero_value() {\n\tcode := `name == \"\" ? foo + bar : foo + name`\n\n\t// If environment has different zero values, then undefined variables\n\t// will have it as default value.\n\tenv := map[string]string{}\n\n\toptions := []expr.Option{\n\t\texpr.Env(env),\n\t\texpr.AllowUndefinedVariables(), // Allow to use undefined variables.\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tenv = map[string]string{\n\t\t\"foo\": \"Hello, \",\n\t\t\"bar\": \"world!\",\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: Hello, world!\n}\n\nfunc ExampleAllowUndefinedVariables_zero_value_functions() {\n\tcode := `words == \"\" ? Split(\"foo,bar\", \",\") : Split(words, \",\")`\n\n\t// Env is map[string]string type on which methods are defined.\n\tenv := mock.MapStringStringEnv{}\n\n\toptions := []expr.Option{\n\t\texpr.Env(env),\n\t\texpr.AllowUndefinedVariables(), // Allow to use undefined variables.\n\t}\n\n\tprogram, err := expr.Compile(code, options...)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: [foo bar]\n}\n\ntype patcher struct{}\n\nfunc (p *patcher) Visit(node *ast.Node) {\n\tswitch n := (*node).(type) {\n\tcase *ast.MemberNode:\n\t\tast.Patch(node, &ast.CallNode{\n\t\t\tCallee: &ast.IdentifierNode{Value: \"get\"},\n\t\t\tArguments: []ast.Node{n.Node, n.Property},\n\t\t})\n\t}\n}\n\nfunc ExamplePatch() {\n\tprogram, err := expr.Compile(\n\t\t`greet.you.world + \"!\"`,\n\t\texpr.Patch(&patcher{}),\n\t)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tenv := map[string]any{\n\t\t\"greet\": \"Hello\",\n\t\t\"get\": func(a, b string) string {\n\t\t\treturn a + \", \" + b\n\t\t},\n\t}\n\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\tfmt.Printf(\"%v\", output)\n\n\t// Output: Hello, you, world!\n}\n\nfunc ExampleWithContext() {\n\tenv := map[string]any{\n\t\t\"fn\": func(ctx context.Context, _, _ int) int {\n\t\t\t// An infinite loop that can be canceled by context.\n\t\t\tfor {\n\t\t\t\tselect {\n\t\t\t\tcase <-ctx.Done():\n\t\t\t\t\treturn 42\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\"ctx\": context.TODO(), // Context should be passed as a variable.\n\t}\n\n\tprogram, err := expr.Compile(`fn(1, 2)`,\n\t\texpr.Env(env),\n\t\texpr.WithContext(\"ctx\"), // Pass context variable name.\n\t)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\t// Cancel context after 100 milliseconds.\n\tctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)\n\tdefer cancel()\n\n\t// After program is compiled, context can be passed to Run.\n\tenv[\"ctx\"] = ctx\n\n\t// Run will return 42 after 100 milliseconds.\n\toutput, err := expr.Run(program, env)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\t// Output: 42\n}\n\nfunc ExampleTimezone() {\n\tprogram, err := expr.Compile(`now().Location().String()`, expr.Timezone(\"Asia/Kamchatka\"))\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\toutput, err := expr.Run(program, nil)\n\tif err != nil {\n\t\tfmt.Printf(\"%v\", err)\n\t\treturn\n\t}\n\n\tfmt.Printf(\"%v\", output)\n\t// Output: Asia/Kamchatka\n}\n\nfunc TestExpr_readme_example(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"greet\": \"Hello, %v!\",\n\t\t\"names\": []string{\"world\", \"you\"},\n\t\t\"sprintf\": fmt.Sprintf,\n\t}\n\n\tcode := `sprintf(greet, names[0])`\n\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\n\trequire.Equal(t, \"Hello, world!\", output)\n}\n\nfunc TestExpr(t *testing.T) {\n\tdate := time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC)\n\toneDay, _ := time.ParseDuration(\"24h\")\n\ttimeNowPlusOneDay := date.Add(oneDay)\n\n\tenv := mock.Env{\n\t\tEmbed: mock.Embed{},\n\t\tAmbiguous: \"\",\n\t\tAny: nil,\n\t\tBool: true,\n\t\tFloat: 0,\n\t\tInt64: 0,\n\t\tInt32: 0,\n\t\tInt: 0,\n\t\tOne: 1,\n\t\tTwo: 2,\n\t\tUint32: 0,\n\t\tString: \"string\",\n\t\tBoolPtr: nil,\n\t\tFloatPtr: nil,\n\t\tIntPtr: nil,\n\t\tIntPtrPtr: nil,\n\t\tStringPtr: nil,\n\t\tFoo: mock.Foo{\n\t\t\tValue: \"foo\",\n\t\t\tBar: mock.Bar{\n\t\t\t\tBaz: \"baz\",\n\t\t\t},\n\t\t},\n\t\tAbstract: nil,\n\t\tArrayOfAny: nil,\n\t\tArrayOfInt: []int{1, 2, 3, 4, 5},\n\t\tArrayOfFoo: []*mock.Foo{{Value: \"foo\"}, {Value: \"bar\"}, {Value: \"baz\"}},\n\t\tMapOfFoo: nil,\n\t\tMapOfAny: nil,\n\t\tFuncParam: nil,\n\t\tFuncParamAny: nil,\n\t\tFuncTooManyReturns: nil,\n\t\tFuncNamed: nil,\n\t\tNilAny: nil,\n\t\tNilFn: nil,\n\t\tNilStruct: nil,\n\t\tVariadic: func(head int, xs ...int) bool {\n\t\t\tsum := 0\n\t\t\tfor _, x := range xs {\n\t\t\t\tsum += x\n\t\t\t}\n\t\t\treturn head == sum\n\t\t},\n\t\tFast: nil,\n\t\tTime: date,\n\t\tTimePlusDay: timeNowPlusOneDay,\n\t\tDuration: oneDay,\n\t}\n\n\ttests := []struct {\n\t\tcode string\n\t\twant any\n\t}{\n\t\t{\n\t\t\t`1`,\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`-.5`,\n\t\t\t-.5,\n\t\t},\n\t\t{\n\t\t\t`true && false || false`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`Int == 0 && Int32 == 0 && Int64 == 0 && Float64 == 0 && Bool && String == \"string\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`-Int64 == 0`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`\"a\" != \"b\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`\"a\" != \"b\" || 1 == 2`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int + 0`,\n\t\t\t0,\n\t\t},\n\t\t{\n\t\t\t`Uint64 + 0`,\n\t\t\t0,\n\t\t},\n\t\t{\n\t\t\t`Uint64 + Int64`,\n\t\t\t0,\n\t\t},\n\t\t{\n\t\t\t`Int32 + Int64`,\n\t\t\t0,\n\t\t},\n\t\t{\n\t\t\t`Float64 + 0`,\n\t\t\tfloat64(0),\n\t\t},\n\t\t{\n\t\t\t`0 + Float64`,\n\t\t\tfloat64(0),\n\t\t},\n\t\t{\n\t\t\t`0 <= Float64`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Float64 < 1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int < 1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`2 + 2 == 4`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`8 % 3`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`2 ** 8`,\n\t\t\tfloat64(256),\n\t\t},\n\t\t{\n\t\t\t`2 ^ 8`,\n\t\t\tfloat64(256),\n\t\t},\n\t\t{\n\t\t\t`-(2-5)**3-2/(+4-3)+-2`,\n\t\t\tfloat64(23),\n\t\t},\n\t\t{\n\t\t\t`\"hello\" + \" \" + \"world\"`,\n\t\t\t\"hello world\",\n\t\t},\n\t\t{\n\t\t\t`0 in -1..1 and 1 in 1..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int32 in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int64 in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`1 in [1, 2, 3] && \"foo\" in {foo: 0, bar: 1} && \"Bar\" in Foo`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`1 in [1.5] || 1 not in [1]`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`One in 0..1 && Two not in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Two not in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Two not in 0..1`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`-1 not in [1]`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Int32 in [10, 20]`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`String matches \"s.+\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`String matches (\"^\" + String + \"$\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`'foo' + 'bar' not matches 'foobar'`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`\"foobar\" contains \"bar\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`\"foobar\" startsWith \"foo\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`\"foobar\" endsWith \"bar\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`(0..10)[5]`,\n\t\t\t5,\n\t\t},\n\t\t{\n\t\t\t`Foo.Bar.Baz`,\n\t\t\t\"baz\",\n\t\t},\n\t\t{\n\t\t\t`Add(10, 5) + GetInt()`,\n\t\t\t15,\n\t\t},\n\t\t{\n\t\t\t`Foo.Method().Baz`,\n\t\t\t`baz (from Foo.Method)`,\n\t\t},\n\t\t{\n\t\t\t`Foo.MethodWithArgs(\"prefix \")`,\n\t\t\t\"prefix foo\",\n\t\t},\n\t\t{\n\t\t\t`len([1, 2, 3])`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`len([1, Two, 3])`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`len([\"hello\", \"world\"])`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`len(\"hello, world\")`,\n\t\t\t12,\n\t\t},\n\t\t{\n\t\t\t`len('北京')`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`len('👍🏻')`, // one grapheme cluster, two code points\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`len('👍')`, // one grapheme cluster, one code point\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`len(ArrayOfInt)`,\n\t\t\t5,\n\t\t},\n\t\t{\n\t\t\t`len({a: 1, b: 2, c: 2})`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`max([1, 2, 3])`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`max(1, 2, 3)`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`min([1, 2, 3])`,\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`min(1, 2, 3)`,\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`{foo: 0, bar: 1}`,\n\t\t\tmap[string]any{\"foo\": 0, \"bar\": 1},\n\t\t},\n\t\t{\n\t\t\t`{foo: 0, bar: 1}`,\n\t\t\tmap[string]any{\"foo\": 0, \"bar\": 1},\n\t\t},\n\t\t{\n\t\t\t`(true ? 0+1 : 2+3) + (false ? -1 : -2)`,\n\t\t\t-1,\n\t\t},\n\t\t{\n\t\t\t`filter(1..9, {# > 7})`,\n\t\t\t[]any{8, 9},\n\t\t},\n\t\t{\n\t\t\t`map(1..3, {# * #})`,\n\t\t\t[]any{1, 4, 9},\n\t\t},\n\t\t{\n\t\t\t`all(1..3, {# > 0})`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`count(1..30, {# % 3 == 0})`,\n\t\t\t10,\n\t\t},\n\t\t{\n\t\t\t`count([true, true, false])`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`\"a\" < \"b\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time.Sub(Time).String() == \"0s\"`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`1 + 1`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`(One * Two) * 3 == One * (Two * 3)`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[1]`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[0] < ArrayOfInt[1]`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[-1]`,\n\t\t\t5,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[1:2]`,\n\t\t\t[]int{2},\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[1:4]`,\n\t\t\t[]int{2, 3, 4},\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[-4:-1]`,\n\t\t\t[]int{2, 3, 4},\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[:3]`,\n\t\t\t[]int{1, 2, 3},\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[3:]`,\n\t\t\t[]int{4, 5},\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[0:5] == ArrayOfInt`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[0:] == ArrayOfInt`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[:5] == ArrayOfInt`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfInt[:] == ArrayOfInt`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`4 in 5..1`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`4..0`,\n\t\t\t[]int{},\n\t\t},\n\t\t{\n\t\t\t`NilStruct`,\n\t\t\t(*mock.Foo)(nil),\n\t\t},\n\t\t{\n\t\t\t`NilAny == nil && nil == NilAny && nil == nil && NilAny == NilAny && NilInt == nil && NilSlice == nil && NilStruct == nil`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`0 == nil || \"str\" == nil || true == nil`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`Variadic(6, 1, 2, 3)`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Variadic(0)`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`String[:]`,\n\t\t\t\"string\",\n\t\t},\n\t\t{\n\t\t\t`String[:3]`,\n\t\t\t\"str\",\n\t\t},\n\t\t{\n\t\t\t`String[:9]`,\n\t\t\t\"string\",\n\t\t},\n\t\t{\n\t\t\t`String[3:9]`,\n\t\t\t\"ing\",\n\t\t},\n\t\t{\n\t\t\t`String[7:9]`,\n\t\t\t\"\",\n\t\t},\n\t\t{\n\t\t\t`map(filter(ArrayOfInt, # >= 3), # + 1)`,\n\t\t\t[]any{4, 5, 6},\n\t\t},\n\t\t{\n\t\t\t`Time < Time + Duration`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time + Duration > Time`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time == Time`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time >= Time`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time <= Time`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`Time == Time + Duration`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`Time != Time`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`TimePlusDay - Duration`,\n\t\t\tdate,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") == duration(\"1h\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`TimePlusDay - Time >= duration(\"24h\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") > duration(\"1m\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") < duration(\"1m\")`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") >= duration(\"1m\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") <= duration(\"1m\")`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") > duration(\"1m\")`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") + duration(\"1m\")`,\n\t\t\ttime.Hour + time.Minute,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") - duration(\"1m\")`,\n\t\t\ttime.Hour - time.Minute,\n\t\t},\n\t\t{\n\t\t\t`7 * duration(\"1h\")`,\n\t\t\t7 * time.Hour,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1h\") * 7`,\n\t\t\t7 * time.Hour,\n\t\t},\n\t\t{\n\t\t\t`duration(\"1s\") * .5`,\n\t\t\t5e8,\n\t\t},\n\t\t{\n\t\t\t`1 /* one */ + 2 // two`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`let x = 1; x + 2`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`map(1..3, let x = #; let y = x * x; y * y)`,\n\t\t\t[]any{1, 16, 81},\n\t\t},\n\t\t{\n\t\t\t`map(1..2, let x = #; map(2..3, let y = #; x + y))`,\n\t\t\t[]any{[]any{3, 4}, []any{4, 5}},\n\t\t},\n\t\t{\n\t\t\t`len(filter(1..99, # % 7 == 0))`,\n\t\t\t14,\n\t\t},\n\t\t{\n\t\t\t`find(ArrayOfFoo, .Value == \"baz\")`,\n\t\t\tenv.ArrayOfFoo[2],\n\t\t},\n\t\t{\n\t\t\t`findIndex(ArrayOfFoo, .Value == \"baz\")`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`filter(ArrayOfFoo, .Value == \"baz\")[0]`,\n\t\t\tenv.ArrayOfFoo[2],\n\t\t},\n\t\t{\n\t\t\t`first(filter(ArrayOfFoo, .Value == \"baz\"))`,\n\t\t\tenv.ArrayOfFoo[2],\n\t\t},\n\t\t{\n\t\t\t`first(filter(ArrayOfFoo, false))`,\n\t\t\tnil,\n\t\t},\n\t\t{\n\t\t\t`findLast(1..9, # % 2 == 0)`,\n\t\t\t8,\n\t\t},\n\t\t{\n\t\t\t`findLastIndex(1..9, # % 2 == 0)`,\n\t\t\t7,\n\t\t},\n\t\t{\n\t\t\t`filter(1..9, # % 2 == 0)[-1]`,\n\t\t\t8,\n\t\t},\n\t\t{\n\t\t\t`last(filter(1..9, # % 2 == 0))`,\n\t\t\t8,\n\t\t},\n\t\t{\n\t\t\t`map(filter(1..9, # % 2 == 0), # * 2)`,\n\t\t\t[]any{4, 8, 12, 16},\n\t\t},\n\t\t{\n\t\t\t`map(map(filter(1..9, # % 2 == 0), # * 2), # * 2)`,\n\t\t\t[]any{8, 16, 24, 32},\n\t\t},\n\t\t{\n\t\t\t`first(map(filter(1..9, # % 2 == 0), # * 2))`,\n\t\t\t4,\n\t\t},\n\t\t{\n\t\t\t`map(filter(1..9, # % 2 == 0), # * 2)[-1]`,\n\t\t\t16,\n\t\t},\n\t\t{\n\t\t\t`len(map(filter(1..9, # % 2 == 0), # * 2))`,\n\t\t\t4,\n\t\t},\n\t\t{\n\t\t\t`len(filter(map(1..9, # * 2), # % 2 == 0))`,\n\t\t\t9,\n\t\t},\n\t\t{\n\t\t\t`first(filter(map(1..9, # * 2), # % 2 == 0))`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`first(map(filter(1..9, # % 2 == 0), # * 2))`,\n\t\t\t4,\n\t\t},\n\t\t{\n\t\t\t`2^3 == 8`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`4/2 == 2`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`.5 in 0..1`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`.5 in ArrayOfInt`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`bitnot(10)`,\n\t\t\t-11,\n\t\t},\n\t\t{\n\t\t\t`bitxor(15, 32)`,\n\t\t\t47,\n\t\t},\n\t\t{\n\t\t\t`bitand(90, 34)`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`bitnand(35, 9)`,\n\t\t\t34,\n\t\t},\n\t\t{\n\t\t\t`bitor(10, 5)`,\n\t\t\t15,\n\t\t},\n\t\t{\n\t\t\t`bitshr(7, 2)`,\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`bitshl(7, 2)`,\n\t\t\t28,\n\t\t},\n\t\t{\n\t\t\t`bitushr(-100, 5)`,\n\t\t\t576460752303423484,\n\t\t},\n\t\t{\n\t\t\t`\"hello\"[1:3]`,\n\t\t\t\"el\",\n\t\t},\n\t\t{\n\t\t\t`[1, 2, 3]?.[0]`,\n\t\t\t1,\n\t\t},\n\t\t{\n\t\t\t`[[1, 2], 3, 4]?.[0]?.[1]`,\n\t\t\t2,\n\t\t},\n\t\t{\n\t\t\t`[nil, 3, 4]?.[0]?.[1]`,\n\t\t\tnil,\n\t\t},\n\t\t{\n\t\t\t`1 > 2 < 3`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`1 < 2 < 3`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`1 < 2 < 3 > 4`,\n\t\t\tfalse,\n\t\t},\n\t\t{\n\t\t\t`1 < 2 < 3 > 2`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`1 < 2 < 3 == true`,\n\t\t\ttrue,\n\t\t},\n\t\t{\n\t\t\t`if 1 > 2 { 333 * 2 + 1 } else { 444 }`,\n\t\t\t444,\n\t\t},\n\t\t{\n\t\t\t`let a = 3;\n\t\t\tlet b = 2;\n\t\t\tif a>b {let c = Add(a, b); c+1} else {Add(10, b)}\n\t\t\t`,\n\t\t\t6,\n\t\t},\n\t\t{\n\t\t\t`if \"a\" < \"b\" {let x = \"a\"; x} else {\"abc\"}`,\n\t\t\t\"a\",\n\t\t},\n\t\t{\n\t\t\t`if 1 == 2 { \"no\" } else if 1 == 1 { \"yes\" } else { \"maybe\" }`,\n\t\t\t\"yes\",\n\t\t},\n\t\t{\n\t\t\t`1; 2; 3`,\n\t\t\t3,\n\t\t},\n\t\t{\n\t\t\t`let a = 1; Add(2, 2); let b = 2; a + b`,\n\t\t\t3,\n\t\t},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\t{\n\t\t\t\tprogram, err := expr.Compile(tt.code, expr.Env(mock.Env{}))\n\t\t\t\trequire.NoError(t, err, \"compile error\")\n\n\t\t\t\tgot, err := expr.Run(program, env)\n\t\t\t\trequire.NoError(t, err, \"run error\")\n\t\t\t\tassert.Equal(t, tt.want, got)\n\t\t\t}\n\t\t\t{\n\t\t\t\tprogram, err := expr.Compile(tt.code, expr.Optimize(false))\n\t\t\t\trequire.NoError(t, err, \"unoptimized\")\n\n\t\t\t\tgot, err := expr.Run(program, env)\n\t\t\t\trequire.NoError(t, err, \"unoptimized\")\n\t\t\t\tassert.Equal(t, tt.want, got, \"unoptimized\")\n\t\t\t}\n\t\t\t{\n\t\t\t\tgot, err := expr.Eval(tt.code, env)\n\t\t\t\trequire.NoError(t, err, \"eval\")\n\t\t\t\tassert.Equal(t, tt.want, got, \"eval\")\n\t\t\t}\n\t\t\t{\n\t\t\t\tprogram, err := expr.Compile(tt.code, expr.Env(mock.Env{}), expr.Optimize(false))\n\t\t\t\trequire.NoError(t, err)\n\n\t\t\t\tcode := program.Node().String()\n\t\t\t\tgot, err := expr.Eval(code, env)\n\t\t\t\trequire.NoError(t, err, code)\n\t\t\t\tassert.Equal(t, tt.want, got, code)\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestExpr_error(t *testing.T) {\n\tenv := mock.Env{\n\t\tArrayOfAny: []any{1, \"2\", 3, true},\n\t}\n\n\ttests := []struct {\n\t\tcode string\n\t\twant string\n\t}{\n\t\t{\n\t\t\t`filter(1..9, # > 9)[0]`,\n\t\t\t`reflect: slice index out of range (1:20)\n | filter(1..9, # > 9)[0]\n | ...................^`,\n\t\t},\n\t\t{\n\t\t\t`ArrayOfAny[-7]`,\n\t\t\t`index out of range: -3 (array length is 4) (1:11)\n | ArrayOfAny[-7]\n | ..........^`,\n\t\t},\n\t\t{\n\t\t\t`reduce(10..1, # + #acc)`,\n\t\t\t`reduce of empty array with no initial value (1:1)\n | reduce(10..1, # + #acc)\n | ^`,\n\t\t},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.code, expr.Env(mock.Env{}))\n\t\t\trequire.NoError(t, err)\n\n\t\t\t_, err = expr.Run(program, env)\n\t\t\trequire.Error(t, err)\n\t\t\tassert.Equal(t, tt.want, err.Error())\n\t\t})\n\t}\n}\n\nfunc TestExpr_optional_chaining(t *testing.T) {\n\tenv := map[string]any{}\n\tprogram, err := expr.Compile(\"foo?.bar.baz\", expr.Env(env), expr.AllowUndefinedVariables())\n\trequire.NoError(t, err)\n\n\tgot, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, nil, got)\n}\n\nfunc TestExpr_optional_chaining_property(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": map[string]any{},\n\t}\n\tprogram, err := expr.Compile(\"foo.bar?.baz\", expr.Env(env))\n\trequire.NoError(t, err)\n\n\tgot, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, nil, got)\n}\n\nfunc TestExpr_optional_chaining_nested_chains(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": map[string]any{\n\t\t\t\"id\": 1,\n\t\t\t\"bar\": []map[string]any{\n\t\t\t\t1: {\n\t\t\t\t\t\"baz\": \"baz\",\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t}\n\tprogram, err := expr.Compile(\"foo?.bar[foo?.id]?.baz\", expr.Env(env))\n\trequire.NoError(t, err)\n\n\tgot, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, \"baz\", got)\n}\n\nfunc TestExpr_optional_chaining_array(t *testing.T) {\n\tenv := map[string]any{}\n\tprogram, err := expr.Compile(\"foo?.[1]?.[2]?.[3]\", expr.Env(env), expr.AllowUndefinedVariables())\n\trequire.NoError(t, err)\n\n\tgot, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, nil, got)\n}\n\nfunc TestExpr_eval_with_env(t *testing.T) {\n\t_, err := expr.Eval(\"true\", expr.Env(map[string]any{}))\n\tassert.Error(t, err)\n\tassert.Contains(t, err.Error(), \"misused\")\n}\n\nfunc TestExpr_fetch_from_func(t *testing.T) {\n\t_, err := expr.Eval(\"foo.Value\", map[string]any{\n\t\t\"foo\": func() {},\n\t})\n\tassert.Error(t, err)\n\tassert.Contains(t, err.Error(), \"cannot fetch Value from func()\")\n}\n\nfunc TestExpr_map_default_values(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": map[string]string{},\n\t\t\"bar\": map[string]*string{},\n\t}\n\n\tinput := `foo['missing'] == '' && bar['missing'] == nil`\n\n\tprogram, err := expr.Compile(input, expr.Env(env))\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\trequire.Equal(t, true, output)\n}\n\nfunc TestExpr_map_default_values_compile_check(t *testing.T) {\n\ttests := []struct {\n\t\tenv any\n\t\tinput string\n\t}{\n\t\t{\n\t\t\tmock.MapStringStringEnv{\"foo\": \"bar\"},\n\t\t\t`Split(foo, sep)`,\n\t\t},\n\t\t{\n\t\t\tmock.MapStringIntEnv{\"foo\": 1},\n\t\t\t`foo / bar`,\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\t_, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AllowUndefinedVariables())\n\t\trequire.NoError(t, err)\n\t}\n}\n\nfunc TestExpr_calls_with_nil(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"equals\": func(a, b any) any {\n\t\t\tassert.Nil(t, a, \"a is not nil\")\n\t\t\tassert.Nil(t, b, \"b is not nil\")\n\t\t\treturn a == b\n\t\t},\n\t\t\"is\": mock.Is{},\n\t}\n\n\tp, err := expr.Compile(\n\t\t\"a == nil && equals(b, nil) && is.Nil(c)\",\n\t\texpr.Env(env),\n\t\texpr.Operator(\"==\", \"equals\"),\n\t\texpr.AllowUndefinedVariables(),\n\t)\n\trequire.NoError(t, err)\n\n\tout, err := expr.Run(p, env)\n\trequire.NoError(t, err)\n\trequire.Equal(t, true, out)\n}\n\nfunc TestExpr_call_float_arg_func_with_int(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"cnv\": func(f float64) any {\n\t\t\treturn f\n\t\t},\n\t}\n\ttests := []struct {\n\t\tinput string\n\t\texpected float64\n\t}{\n\t\t{\"-1\", -1.0},\n\t\t{\"1+1\", 2.0},\n\t\t{\"+1\", 1.0},\n\t\t{\"1-1\", 0.0},\n\t\t{\"1/1\", 1.0},\n\t\t{\"1*1\", 1.0},\n\t\t{\"1^1\", 1.0},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.input, func(t *testing.T) {\n\t\t\tp, err := expr.Compile(fmt.Sprintf(\"cnv(%s)\", tt.input), expr.Env(env))\n\t\t\trequire.NoError(t, err)\n\n\t\t\tout, err := expr.Run(p, env)\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, tt.expected, out)\n\t\t})\n\t}\n}\n\nfunc TestConstExpr_error_panic(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"divide\": func(a, b int) int { return a / b },\n\t}\n\n\t_, err := expr.Compile(\n\t\t`1 + divide(1, 0)`,\n\t\texpr.Env(env),\n\t\texpr.ConstExpr(\"divide\"),\n\t)\n\trequire.Error(t, err)\n\trequire.Equal(t, \"compile error: integer divide by zero (1:5)\\n | 1 + divide(1, 0)\\n | ....^\", err.Error())\n}\n\ntype divideError struct{ Message string }\n\nfunc (e divideError) Error() string {\n\treturn e.Message\n}\n\nfunc TestConstExpr_error_as_error(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"divide\": func(a, b int) (int, error) {\n\t\t\tif b == 0 {\n\t\t\t\treturn 0, divideError{\"integer divide by zero\"}\n\t\t\t}\n\t\t\treturn a / b, nil\n\t\t},\n\t}\n\n\t_, err := expr.Compile(\n\t\t`1 + divide(1, 0)`,\n\t\texpr.Env(env),\n\t\texpr.ConstExpr(\"divide\"),\n\t)\n\trequire.Error(t, err)\n\trequire.Equal(t, \"integer divide by zero\", err.Error())\n\trequire.IsType(t, divideError{}, err)\n}\n\nfunc TestConstExpr_error_wrong_type(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"divide\": 0,\n\t}\n\tassert.Panics(t, func() {\n\t\t_, _ = expr.Compile(\n\t\t\t`1 + divide(1, 0)`,\n\t\t\texpr.Env(env),\n\t\t\texpr.ConstExpr(\"divide\"),\n\t\t)\n\t})\n}\n\nfunc TestConstExpr_error_no_env(t *testing.T) {\n\tassert.Panics(t, func() {\n\t\t_, _ = expr.Compile(\n\t\t\t`1 + divide(1, 0)`,\n\t\t\texpr.ConstExpr(\"divide\"),\n\t\t)\n\t})\n}\n\nvar stringer = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()\n\ntype stringerPatcher struct{}\n\nfunc (p *stringerPatcher) Visit(node *ast.Node) {\n\tt := (*node).Type()\n\tif t == nil {\n\t\treturn\n\t}\n\tif t.Implements(stringer) {\n\t\tast.Patch(node, &ast.CallNode{\n\t\t\tCallee: &ast.MemberNode{\n\t\t\t\tNode: *node,\n\t\t\t\tProperty: &ast.StringNode{Value: \"String\"},\n\t\t\t},\n\t\t})\n\t}\n}\n\nfunc TestPatch(t *testing.T) {\n\tprogram, err := expr.Compile(\n\t\t`Foo == \"Foo.String\"`,\n\t\texpr.Env(mock.Env{}),\n\t\texpr.Patch(&mock.StringerPatcher{}),\n\t)\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, mock.Env{})\n\trequire.NoError(t, err)\n\trequire.Equal(t, true, output)\n}\n\nfunc TestCompile_exposed_error(t *testing.T) {\n\t_, err := expr.Compile(`1 == true`)\n\trequire.Error(t, err)\n\n\tfileError, ok := err.(*file.Error)\n\trequire.True(t, ok, \"error should be of type *file.Error\")\n\trequire.Equal(t, \"invalid operation: == (mismatched types int and bool) (1:3)\\n | 1 == true\\n | ..^\", fileError.Error())\n\trequire.Equal(t, 2, fileError.Column)\n\trequire.Equal(t, 1, fileError.Line)\n\n\tb, err := json.Marshal(err)\n\trequire.NoError(t, err)\n\trequire.Equal(t,\n\t\t`{\"from\":2,\"to\":4,\"line\":1,\"column\":2,\"message\":\"invalid operation: == (mismatched types int and bool)\",\"snippet\":\"\\n | 1 == true\\n | ..^\",\"prev\":null}`,\n\t\tstring(b),\n\t)\n}\n\nfunc TestAsBool_exposed_error(t *testing.T) {\n\t_, err := expr.Compile(`42`, expr.AsBool())\n\trequire.Error(t, err)\n\n\t_, ok := err.(*file.Error)\n\trequire.False(t, ok, \"error must not be of type *file.Error\")\n\trequire.Equal(t, \"expected bool, but got int\", err.Error())\n}\n\nfunc TestEval_exposed_error(t *testing.T) {\n\t_, err := expr.Eval(`1 % 0`, nil)\n\trequire.Error(t, err)\n\n\tfileError, ok := err.(*file.Error)\n\trequire.True(t, ok, \"error should be of type *file.Error\")\n\trequire.Equal(t, \"runtime error: integer divide by zero (1:3)\\n | 1 % 0\\n | ..^\", fileError.Error())\n\trequire.Equal(t, 2, fileError.Column)\n\trequire.Equal(t, 1, fileError.Line)\n}\n\nfunc TestCompile_exposed_error_with_multiline_script(t *testing.T) {\n\t_, err := expr.Compile(\"{\\n\\ta: 1,\\n\\tb: #,\\n\\tc: 3,\\n}\")\n\trequire.Error(t, err)\n\n\tfileError, ok := err.(*file.Error)\n\trequire.True(t, ok, \"error should be of type *file.Error\")\n\trequire.Equal(t, \"unexpected token Operator(\\\"#\\\") (3:5)\\n | b: #,\\n | ....^\", fileError.Error())\n\trequire.Equal(t, 4, fileError.Column)\n\trequire.Equal(t, 3, fileError.Line)\n}\n\nfunc TestIssue105(t *testing.T) {\n\ttype A struct {\n\t\tField string\n\t}\n\ttype B struct {\n\t\tField int\n\t}\n\ttype C struct {\n\t\tA\n\t\tB\n\t}\n\ttype Env struct {\n\t\tC\n\t}\n\n\tcode := `\n\t\tA.Field == '' &&\n\t\tC.A.Field == '' &&\n\t\tB.Field == 0 &&\n\t\tC.B.Field == 0\n\t`\n\n\t_, err := expr.Compile(code, expr.Env(Env{}))\n\trequire.NoError(t, err)\n}\n\nfunc TestIssue_nested_closures(t *testing.T) {\n\tcode := `all(1..3, { all(1..3, { # > 0 }) and # > 0 })`\n\n\tprogram, err := expr.Compile(code)\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, nil)\n\trequire.NoError(t, err)\n\trequire.True(t, output.(bool))\n}\n\nfunc TestIssue138(t *testing.T) {\n\tenv := map[string]any{}\n\n\t_, err := expr.Compile(`1 / (1 - 1)`, expr.Env(env))\n\trequire.NoError(t, err)\n\n\t_, err = expr.Compile(`1 % 0`, expr.Env(env))\n\trequire.Error(t, err)\n\trequire.Equal(t, \"integer divide by zero (1:3)\\n | 1 % 0\\n | ..^\", err.Error())\n}\n\nfunc TestIssue154(t *testing.T) {\n\ttype Data struct {\n\t\tArray *[2]any\n\t\tSlice *[]any\n\t\tMap *map[string]any\n\t\tString *string\n\t}\n\n\ttype Env struct {\n\t\tData *Data\n\t}\n\n\tb := true\n\ti := 10\n\ts := \"value\"\n\n\tArray := [2]any{\n\t\t&b,\n\t\t&i,\n\t}\n\n\tSlice := []any{\n\t\t&b,\n\t\t&i,\n\t}\n\n\tMap := map[string]any{\n\t\t\"Bool\": &b,\n\t\t\"Int\": &i,\n\t}\n\n\tenv := Env{\n\t\tData: &Data{\n\t\t\tArray: &Array,\n\t\t\tSlice: &Slice,\n\t\t\tMap: &Map,\n\t\t\tString: &s,\n\t\t},\n\t}\n\n\ttests := []string{\n\t\t`Data.Array[0] == true`,\n\t\t`Data.Array[1] == 10`,\n\t\t`Data.Slice[0] == true`,\n\t\t`Data.Slice[1] == 10`,\n\t\t`Data.Map[\"Bool\"] == true`,\n\t\t`Data.Map[\"Int\"] == 10`,\n\t\t`Data.String == \"value\"`,\n\t}\n\n\tfor _, input := range tests {\n\t\tprogram, err := expr.Compile(input, expr.Env(env))\n\t\trequire.NoError(t, err, input)\n\n\t\toutput, err := expr.Run(program, env)\n\t\trequire.NoError(t, err)\n\t\tassert.True(t, output.(bool), input)\n\t}\n}\n\nfunc TestIssue270(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"int8\": int8(1),\n\t\t\"int16\": int16(3),\n\t\t\"int32\": int32(5),\n\t\t\"int64\": int64(7),\n\t\t\"uint8\": uint8(11),\n\t\t\"uint16\": uint16(13),\n\t\t\"uint32\": uint32(17),\n\t\t\"uint64\": uint64(19),\n\t\t\"int8a\": uint(23),\n\t\t\"int8b\": uint(29),\n\t\t\"int16a\": uint(31),\n\t\t\"int16b\": uint(37),\n\t\t\"int32a\": uint(41),\n\t\t\"int32b\": uint(43),\n\t\t\"int64a\": uint(47),\n\t\t\"int64b\": uint(53),\n\t\t\"uint8a\": uint(59),\n\t\t\"uint8b\": uint(61),\n\t\t\"uint16a\": uint(67),\n\t\t\"uint16b\": uint(71),\n\t\t\"uint32a\": uint(73),\n\t\t\"uint32b\": uint(79),\n\t\t\"uint64a\": uint(83),\n\t\t\"uint64b\": uint(89),\n\t\t\"float32a\": float32(97),\n\t\t\"float32b\": float32(101),\n\t\t\"float64a\": float64(103),\n\t\t\"float64b\": float64(107),\n\t}\n\tfor _, each := range []struct {\n\t\tinput string\n\t}{\n\t\t{\"int8 / int16\"},\n\t\t{\"int32 / int64\"},\n\t\t{\"uint8 / uint16\"},\n\t\t{\"uint32 / uint64\"},\n\t\t{\"int8 / uint64\"},\n\t\t{\"int64 / uint8\"},\n\t\t{\"int8a / int8b\"},\n\t\t{\"int16a / int16b\"},\n\t\t{\"int32a / int32b\"},\n\t\t{\"int64a / int64b\"},\n\t\t{\"uint8a / uint8b\"},\n\t\t{\"uint16a / uint16b\"},\n\t\t{\"uint32a / uint32b\"},\n\t\t{\"uint64a / uint64b\"},\n\t\t{\"float32a / float32b\"},\n\t\t{\"float64a / float64b\"},\n\t} {\n\t\tp, err := expr.Compile(each.input, expr.Env(env))\n\t\trequire.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\trequire.NoError(t, err)\n\t\trequire.IsType(t, float64(0), out)\n\t}\n}\n\nfunc TestIssue271(t *testing.T) {\n\ttype BarArray []float64\n\n\ttype Foo struct {\n\t\tBar BarArray\n\t\tBaz int\n\t}\n\n\ttype Env struct {\n\t\tFoo Foo\n\t}\n\n\tcode := `Foo.Bar[0]`\n\n\tprogram, err := expr.Compile(code, expr.Env(Env{}))\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, Env{\n\t\tFoo: Foo{\n\t\t\tBar: BarArray{1.0, 2.0, 3.0},\n\t\t},\n\t})\n\trequire.NoError(t, err)\n\trequire.Equal(t, 1.0, output)\n}\n\ntype Issue346Array []Issue346Type\n\ntype Issue346Type struct {\n\tBar string\n}\n\nfunc (i Issue346Array) Len() int {\n\treturn len(i)\n}\n\nfunc TestIssue346(t *testing.T) {\n\tcode := `Foo[0].Bar`\n\n\tenv := map[string]any{\n\t\t\"Foo\": Issue346Array{\n\t\t\t{Bar: \"bar\"},\n\t\t},\n\t}\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\trequire.Equal(t, \"bar\", output)\n}\n\nfunc TestCompile_allow_to_use_interface_to_get_an_element_from_map(t *testing.T) {\n\tcode := `{\"value\": \"ok\"}[vars.key]`\n\tenv := map[string]any{\n\t\t\"vars\": map[string]any{\n\t\t\t\"key\": \"value\",\n\t\t},\n\t}\n\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\tassert.NoError(t, err)\n\tassert.Equal(t, \"ok\", out)\n\n\tt.Run(\"with allow undefined variables\", func(t *testing.T) {\n\t\tcode := `{'key': 'value'}[Key]`\n\t\tenv := mock.MapStringStringEnv{}\n\t\toptions := []expr.Option{\n\t\t\texpr.AllowUndefinedVariables(),\n\t\t}\n\n\t\tprogram, err := expr.Compile(code, options...)\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(program, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, nil, out)\n\t})\n}\n\nfunc TestFastCall(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"func\": func(in any) float64 {\n\t\t\treturn 8\n\t\t},\n\t}\n\tcode := `func(\"8\")`\n\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\tassert.NoError(t, err)\n\tassert.Equal(t, float64(8), out)\n}\n\nfunc TestFastCall_OpCallFastErr(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"func\": func(...any) (any, error) {\n\t\t\treturn 8, nil\n\t\t},\n\t}\n\tcode := `func(\"8\")`\n\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\tassert.NoError(t, err)\n\tassert.Equal(t, 8, out)\n}\n\nfunc TestRun_custom_func_returns_an_error_as_second_arg(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"semver\": func(value string, cmp string) (bool, error) { return true, nil },\n\t}\n\n\tp, err := expr.Compile(`semver(\"1.2.3\", \"= 1.2.3\")`, expr.Env(env))\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(p, env)\n\tassert.NoError(t, err)\n\tassert.Equal(t, true, out)\n}\n\nfunc TestFunction(t *testing.T) {\n\tadd := expr.Function(\n\t\t\"add\",\n\t\tfunc(p ...any) (any, error) {\n\t\t\tout := 0\n\t\t\tfor _, each := range p {\n\t\t\t\tout += each.(int)\n\t\t\t}\n\t\t\treturn out, nil\n\t\t},\n\t\tnew(func(...int) int),\n\t)\n\n\tp, err := expr.Compile(`add() + add(1) + add(1, 2) + add(1, 2, 3) + add(1, 2, 3, 4)`, add)\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(p, nil)\n\tassert.NoError(t, err)\n\tassert.Equal(t, 20, out)\n}\n\n// Nil coalescing operator\nfunc TestRun_NilCoalescingOperator(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": map[string]any{\n\t\t\t\"bar\": \"value\",\n\t\t},\n\t}\n\n\tt.Run(\"value\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`foo.bar ?? \"default\"`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, \"value\", out)\n\t})\n\n\tt.Run(\"default\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`foo.baz ?? \"default\"`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, \"default\", out)\n\t})\n\n\tt.Run(\"default with chain\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`foo?.bar ?? \"default\"`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, map[string]any{})\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, \"default\", out)\n\t})\n}\n\nfunc TestEval_nil_in_maps(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"m\": map[any]any{nil: \"bar\"},\n\t\t\"empty\": map[any]any{},\n\t}\n\tt.Run(\"nil key exists\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`m[nil]`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, \"bar\", out)\n\t})\n\tt.Run(\"no nil key\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`empty[nil]`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, nil, out)\n\t})\n\tt.Run(\"nil in m\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`nil in m`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, true, out)\n\t})\n\tt.Run(\"nil in empty\", func(t *testing.T) {\n\t\tp, err := expr.Compile(`nil in empty`, expr.Env(env))\n\t\tassert.NoError(t, err)\n\n\t\tout, err := expr.Run(p, env)\n\t\tassert.NoError(t, err)\n\t\tassert.Equal(t, false, out)\n\t})\n}\n\n// Test the use of env keyword. Forms env[] and env[”] are valid.\n// The enclosed identifier must be in the expression env.\nfunc TestEnv_keyword(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"space test\": \"ok\",\n\t\t\"space_test\": \"not ok\", // Seems to be some underscore substituting happening, check that.\n\t\t\"Section 1-2a\": \"ok\",\n\t\t`c:\\ndrive\\2015 Information Table`: \"ok\",\n\t\t\"%*worst function name ever!!\": func() string {\n\t\t\treturn \"ok\"\n\t\t}(),\n\t\t\"1\": \"o\",\n\t\t\"2\": \"k\",\n\t\t\"num\": 10,\n\t\t\"mylist\": []int{1, 2, 3, 4, 5},\n\t\t\"MIN\": func(a, b int) int {\n\t\t\tif a < b {\n\t\t\t\treturn a\n\t\t\t} else {\n\t\t\t\treturn b\n\t\t\t}\n\t\t},\n\t\t\"red\": \"n\",\n\t\t\"irect\": \"um\",\n\t\t\"String Map\": map[string]string{\n\t\t\t\"one\": \"two\",\n\t\t\t\"three\": \"four\",\n\t\t},\n\t\t\"OtherMap\": map[string]string{\n\t\t\t\"a\": \"b\",\n\t\t\t\"c\": \"d\",\n\t\t},\n\t}\n\n\t// No error cases\n\tvar tests = []struct {\n\t\tcode string\n\t\twant any\n\t}{\n\t\t{\"$env['space test']\", \"ok\"},\n\t\t{\"$env['Section 1-2a']\", \"ok\"},\n\t\t{`$env[\"c:\\\\ndrive\\\\2015 Information Table\"]`, \"ok\"},\n\t\t{\"$env['%*worst function name ever!!']\", \"ok\"},\n\t\t{\"$env['String Map'].one\", \"two\"},\n\t\t{\"$env['1'] + $env['2']\", \"ok\"},\n\t\t{\"1 + $env['num'] + $env['num']\", 21},\n\t\t{\"MIN($env['num'],0)\", 0},\n\t\t{\"$env['nu' + 'm']\", 10},\n\t\t{\"$env[red + irect]\", 10},\n\t\t{\"$env['String Map']?.five\", \"\"},\n\t\t{\"$env.red\", \"n\"},\n\t\t{\"$env?.unknown\", nil},\n\t\t{\"$env.mylist[1]\", 2},\n\t\t{\"$env?.OtherMap?.a\", \"b\"},\n\t\t{\"$env?.OtherMap?.d\", \"\"},\n\t\t{\"'num' in $env\", true},\n\t\t{\"get($env, 'num')\", 10},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\n\t\t\tprogram, err := expr.Compile(tt.code, expr.Env(env))\n\t\t\trequire.NoError(t, err, \"compile error\")\n\n\t\t\tgot, err := expr.Run(program, env)\n\t\t\trequire.NoError(t, err, \"execution error\")\n\n\t\t\tassert.Equal(t, tt.want, got, tt.code)\n\t\t})\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tgot, err := expr.Eval(tt.code, env)\n\t\t\trequire.NoError(t, err, \"eval error: \"+tt.code)\n\n\t\t\tassert.Equal(t, tt.want, got, \"eval: \"+tt.code)\n\t\t})\n\t}\n\n\t// error cases\n\ttests = []struct {\n\t\tcode string\n\t\twant any\n\t}{\n\t\t{\"env()\", \"bad\"},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\t_, err := expr.Eval(tt.code, expr.Env(env))\n\t\t\trequire.Error(t, err, \"compile error\")\n\n\t\t})\n\t}\n}\n\nfunc TestEnv_keyword_with_custom_functions(t *testing.T) {\n\tfn := expr.Function(\"fn\", func(params ...any) (any, error) {\n\t\treturn \"ok\", nil\n\t})\n\n\tvar tests = []struct {\n\t\tcode string\n\t\terror bool\n\t}{\n\t\t{`fn()`, false},\n\t\t{`$env.fn()`, true},\n\t\t{`$env[\"fn\"]`, true},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\t_, err := expr.Compile(tt.code, expr.Env(mock.Env{}), fn)\n\t\t\tif tt.error {\n\t\t\t\trequire.Error(t, err)\n\t\t\t} else {\n\t\t\t\trequire.NoError(t, err)\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestIssue401(t *testing.T) {\n\tprogram, err := expr.Compile(\"(a - b + c) / d\", expr.AllowUndefinedVariables())\n\trequire.NoError(t, err, \"compile error\")\n\n\toutput, err := expr.Run(program, map[string]any{\n\t\t\"a\": 1,\n\t\t\"b\": 2,\n\t\t\"c\": 3,\n\t\t\"d\": 4,\n\t})\n\trequire.NoError(t, err, \"run error\")\n\trequire.Equal(t, 0.5, output)\n}\n\nfunc TestEval_slices_out_of_bound(t *testing.T) {\n\ttests := []struct {\n\t\tcode string\n\t\twant any\n\t}{\n\t\t{\"[1, 2, 3][:99]\", []any{1, 2, 3}},\n\t\t{\"[1, 2, 3][99:]\", []any{}},\n\t\t{\"[1, 2, 3][:-99]\", []any{}},\n\t\t{\"[1, 2, 3][-99:]\", []any{1, 2, 3}},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tgot, err := expr.Eval(tt.code, nil)\n\t\t\trequire.NoError(t, err, \"eval error: \"+tt.code)\n\t\t\tassert.Equal(t, tt.want, got, \"eval: \"+tt.code)\n\t\t})\n\t}\n}\n\nfunc TestExpr_timeout(t *testing.T) {\n\ttests := []struct{ code string }{\n\t\t{`-999999..999999`},\n\t\t{`map(1..999999, 1..999999)`},\n\t\t{`map(1..999999, repeat('a', #))`},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.code)\n\t\t\trequire.NoError(t, err)\n\n\t\t\ttimeout := make(chan bool, 1)\n\t\t\tgo func() {\n\t\t\t\ttime.Sleep(time.Second)\n\t\t\t\ttimeout <- true\n\t\t\t}()\n\n\t\t\tdone := make(chan bool, 1)\n\t\t\tgo func() {\n\t\t\t\tout, err := expr.Run(program, nil)\n\t\t\t\t// Make sure out is used.\n\t\t\t\t_ = fmt.Sprintf(\"%v\", out)\n\t\t\t\tassert.Error(t, err)\n\t\t\t\tdone <- true\n\t\t\t}()\n\n\t\t\tselect {\n\t\t\tcase <-done:\n\t\t\t\t// Success.\n\t\t\tcase <-timeout:\n\t\t\t\tt.Fatal(\"timeout\")\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestIssue432(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"func\": func(\n\t\t\tparamUint32 uint32,\n\t\t\tparamUint16 uint16,\n\t\t\tparamUint8 uint8,\n\t\t\tparamUint uint,\n\t\t\tparamInt32 int32,\n\t\t\tparamInt16 int16,\n\t\t\tparamInt8 int8,\n\t\t\tparamInt int,\n\t\t\tparamFloat64 float64,\n\t\t\tparamFloat32 float32,\n\t\t) float64 {\n\t\t\treturn float64(paramUint32) + float64(paramUint16) + float64(paramUint8) + float64(paramUint) +\n\t\t\t\tfloat64(paramInt32) + float64(paramInt16) + float64(paramInt8) + float64(paramInt) +\n\t\t\t\tfloat64(paramFloat64) + float64(paramFloat32)\n\t\t},\n\t}\n\tcode := `func(1,1,1,1,1,1,1,1,1,1)`\n\n\tprogram, err := expr.Compile(code, expr.Env(env))\n\tassert.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\tassert.NoError(t, err)\n\tassert.Equal(t, float64(10), out)\n}\n\nfunc TestIssue462(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"foo\": func() (string, error) {\n\t\t\treturn \"bar\", nil\n\t\t},\n\t}\n\t_, err := expr.Compile(`$env.unknown(int())`, expr.Env(env))\n\trequire.Error(t, err)\n}\n\nfunc TestIssue_embedded_pointer_struct(t *testing.T) {\n\tvar tests = []struct {\n\t\tinput string\n\t\tenv mock.Env\n\t\twant any\n\t}{\n\t\t{\n\t\t\tinput: \"EmbedPointerEmbedInt > 0\",\n\t\t\tenv: mock.Env{\n\t\t\t\tEmbed: mock.Embed{\n\t\t\t\t\tEmbedPointerEmbed: &mock.EmbedPointerEmbed{\n\t\t\t\t\t\tEmbedPointerEmbedInt: 123,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\twant: true,\n\t\t},\n\t\t{\n\t\t\tinput: \"(Embed).EmbedPointerEmbedInt > 0\",\n\t\t\tenv: mock.Env{\n\t\t\t\tEmbed: mock.Embed{\n\t\t\t\t\tEmbedPointerEmbed: &mock.EmbedPointerEmbed{\n\t\t\t\t\t\tEmbedPointerEmbedInt: 123,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\twant: true,\n\t\t},\n\t\t{\n\t\t\tinput: \"(Embed).EmbedPointerEmbedInt > 0\",\n\t\t\tenv: mock.Env{\n\t\t\t\tEmbed: mock.Embed{\n\t\t\t\t\tEmbedPointerEmbed: &mock.EmbedPointerEmbed{\n\t\t\t\t\t\tEmbedPointerEmbedInt: 0,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\twant: false,\n\t\t},\n\t\t{\n\t\t\tinput: \"(Embed).EmbedPointerEmbedMethod(0)\",\n\t\t\tenv: mock.Env{\n\t\t\t\tEmbed: mock.Embed{\n\t\t\t\t\tEmbedPointerEmbed: &mock.EmbedPointerEmbed{\n\t\t\t\t\t\tEmbedPointerEmbedInt: 0,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\twant: \"\",\n\t\t},\n\t\t{\n\t\t\tinput: \"(Embed).EmbedPointerEmbedPointerReceiverMethod(0)\",\n\t\t\tenv: mock.Env{\n\t\t\t\tEmbed: mock.Embed{\n\t\t\t\t\tEmbedPointerEmbed: nil,\n\t\t\t\t},\n\t\t\t},\n\t\t\twant: \"\",\n\t\t},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.input, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.input, expr.Env(tt.env))\n\t\t\trequire.NoError(t, err)\n\n\t\t\tout, err := expr.Run(program, tt.env)\n\t\t\trequire.NoError(t, err)\n\n\t\t\trequire.Equal(t, tt.want, out)\n\t\t})\n\t}\n}\n\nfunc TestIssue474(t *testing.T) {\n\ttestCases := []struct {\n\t\tcode string\n\t\tfail bool\n\t}{\n\t\t{\n\t\t\tcode: `func(\"invalid\")`,\n\t\t\tfail: true,\n\t\t},\n\t\t{\n\t\t\tcode: `func(true)`,\n\t\t\tfail: true,\n\t\t},\n\t\t{\n\t\t\tcode: `func([])`,\n\t\t\tfail: true,\n\t\t},\n\t\t{\n\t\t\tcode: `func({})`,\n\t\t\tfail: true,\n\t\t},\n\t\t{\n\t\t\tcode: `func(1)`,\n\t\t\tfail: false,\n\t\t},\n\t\t{\n\t\t\tcode: `func(1.5)`,\n\t\t\tfail: false,\n\t\t},\n\t}\n\n\tfor _, tc := range testCases {\n\t\tltc := tc\n\t\tt.Run(ltc.code, func(t *testing.T) {\n\t\t\tt.Parallel()\n\t\t\tfunction := expr.Function(\"func\", func(params ...any) (any, error) {\n\t\t\t\treturn true, nil\n\t\t\t}, new(func(float64) bool))\n\t\t\t_, err := expr.Compile(ltc.code, function)\n\t\t\tif ltc.fail {\n\t\t\t\tif err == nil {\n\t\t\t\t\tt.Error(\"expected an error, but it was nil\")\n\t\t\t\t\tt.FailNow()\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif err != nil {\n\t\t\t\t\tt.Errorf(\"expected nil, but it was %v\", err)\n\t\t\t\t\tt.FailNow()\n\t\t\t\t}\n\t\t\t}\n\t\t})\n\t}\n}\n\nfunc TestRaceCondition_variables(t *testing.T) {\n\tprogram, err := expr.Compile(`let foo = 1; foo + 1`, expr.Env(mock.Env{}))\n\trequire.NoError(t, err)\n\n\tvar wg sync.WaitGroup\n\n\tfor i := 0; i < 10; i++ {\n\t\twg.Add(1)\n\t\tgo func() {\n\t\t\tdefer wg.Done()\n\t\t\tout, err := expr.Run(program, mock.Env{})\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, 2, out)\n\t\t}()\n\t}\n\n\twg.Wait()\n}\n\nfunc TestOperatorDependsOnEnv(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"plus\": func(a, b int) int {\n\t\t\treturn 42\n\t\t},\n\t}\n\tprogram, err := expr.Compile(`1 + 2`, expr.Operator(\"+\", \"plus\"), expr.Env(env))\n\trequire.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, 42, out)\n}\n\nfunc TestIssue624(t *testing.T) {\n\ttype tag struct {\n\t\tName string\n\t}\n\n\ttype item struct {\n\t\tTags []tag\n\t}\n\n\ti := item{\n\t\tTags: []tag{\n\t\t\t{Name: \"one\"},\n\t\t\t{Name: \"two\"},\n\t\t},\n\t}\n\n\trule := `[\ntrue && true, \none(Tags, .Name in [\"one\"]), \none(Tags, .Name in [\"two\"]), \none(Tags, .Name in [\"one\"]) && one(Tags, .Name in [\"two\"])\n]`\n\tresp, err := expr.Eval(rule, i)\n\trequire.NoError(t, err)\n\trequire.Equal(t, []interface{}{true, true, true, true}, resp)\n}\n\nfunc TestPredicateCombination(t *testing.T) {\n\ttests := []struct {\n\t\tcode1 string\n\t\tcode2 string\n\t}{\n\t\t{\"all(1..3, {# > 0}) && all(1..3, {# < 4})\", \"all(1..3, {# > 0 && # < 4})\"},\n\t\t{\"all(1..3, {# > 1}) && all(1..3, {# < 4})\", \"all(1..3, {# > 1 && # < 4})\"},\n\t\t{\"all(1..3, {# > 0}) && all(1..3, {# < 2})\", \"all(1..3, {# > 0 && # < 2})\"},\n\t\t{\"all(1..3, {# > 1}) && all(1..3, {# < 2})\", \"all(1..3, {# > 1 && # < 2})\"},\n\n\t\t{\"any(1..3, {# > 0}) || any(1..3, {# < 4})\", \"any(1..3, {# > 0 || # < 4})\"},\n\t\t{\"any(1..3, {# > 1}) || any(1..3, {# < 4})\", \"any(1..3, {# > 1 || # < 4})\"},\n\t\t{\"any(1..3, {# > 0}) || any(1..3, {# < 2})\", \"any(1..3, {# > 0 || # < 2})\"},\n\t\t{\"any(1..3, {# > 1}) || any(1..3, {# < 2})\", \"any(1..3, {# > 1 || # < 2})\"},\n\n\t\t{\"none(1..3, {# > 0}) && none(1..3, {# < 4})\", \"none(1..3, {# > 0 || # < 4})\"},\n\t\t{\"none(1..3, {# > 1}) && none(1..3, {# < 4})\", \"none(1..3, {# > 1 || # < 4})\"},\n\t\t{\"none(1..3, {# > 0}) && none(1..3, {# < 2})\", \"none(1..3, {# > 0 || # < 2})\"},\n\t\t{\"none(1..3, {# > 1}) && none(1..3, {# < 2})\", \"none(1..3, {# > 1 || # < 2})\"},\n\t}\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code1, func(t *testing.T) {\n\t\t\tout1, err := expr.Eval(tt.code1, nil)\n\t\t\trequire.NoError(t, err)\n\n\t\t\tout2, err := expr.Eval(tt.code2, nil)\n\t\t\trequire.NoError(t, err)\n\n\t\t\trequire.Equal(t, out1, out2)\n\t\t})\n\t}\n}\n\nfunc TestArrayComparison(t *testing.T) {\n\ttests := []struct {\n\t\tenv any\n\t\tcode string\n\t}{\n\t\t{[]string{\"A\", \"B\"}, \"foo == ['A', 'B']\"},\n\t\t{[]int{1, 2}, \"foo == [1, 2]\"},\n\t\t{[]uint8{1, 2}, \"foo == [1, 2]\"},\n\t\t{[]float64{1.1, 2.2}, \"foo == [1.1, 2.2]\"},\n\t\t{[]any{\"A\", 1, 1.1, true}, \"foo == ['A', 1, 1.1, true]\"},\n\t\t{[]string{\"A\", \"B\"}, \"foo != [1, 2]\"},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tenv := map[string]any{\"foo\": tt.env}\n\t\t\tprogram, err := expr.Compile(tt.code, expr.Env(env))\n\t\t\trequire.NoError(t, err)\n\n\t\t\tout, err := expr.Run(program, env)\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, true, out)\n\t\t})\n\t}\n}\n\nfunc TestIssue_570(t *testing.T) {\n\ttype Student struct {\n\t\tName string\n\t}\n\n\tenv := map[string]any{\n\t\t\"student\": (*Student)(nil),\n\t}\n\n\tprogram, err := expr.Compile(\"student?.Name\", expr.Env(env))\n\trequire.NoError(t, err)\n\n\tout, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\trequire.IsType(t, nil, out)\n}\n\nfunc TestIssue_integer_truncated_by_compiler(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"fn\": func(x byte) byte {\n\t\t\treturn x\n\t\t},\n\t}\n\n\t_, err := expr.Compile(\"fn(255)\", expr.Env(env))\n\trequire.NoError(t, err)\n\n\t_, err = expr.Compile(\"fn(256)\", expr.Env(env))\n\trequire.Error(t, err)\n}\n\nfunc TestExpr_crash(t *testing.T) {\n\tcontent, err := os.ReadFile(\"testdata/crash.txt\")\n\trequire.NoError(t, err)\n\n\t_, err = expr.Compile(string(content))\n\trequire.Error(t, err)\n}\n\nfunc TestExpr_crash_with_zero(t *testing.T) {\n\tcode := \"if\\x00\"\n\t_, err := expr.Compile(code)\n\trequire.Error(t, err)\n}\n\nfunc TestExpr_nil_op_str(t *testing.T) {\n\t// Let's test operators, which do `.(string)` in VM, also check for nil.\n\n\tvar str *string = nil\n\tenv := map[string]any{\n\t\t\"nilString\": str,\n\t}\n\n\ttests := []struct{ code string }{\n\t\t{`nilString == \"str\"`},\n\t\t{`nilString contains \"str\"`},\n\t\t{`nilString matches \"str\"`},\n\t\t{`nilString startsWith \"str\"`},\n\t\t{`nilString endsWith \"str\"`},\n\n\t\t{`\"str\" == nilString`},\n\t\t{`\"str\" contains nilString`},\n\t\t{`\"str\" matches nilString`},\n\t\t{`\"str\" startsWith nilString`},\n\t\t{`\"str\" endsWith nilString`},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.code)\n\t\t\trequire.NoError(t, err)\n\n\t\t\toutput, err := expr.Run(program, env)\n\t\t\trequire.NoError(t, err)\n\t\t\trequire.Equal(t, false, output)\n\t\t})\n\t}\n}\n\nfunc TestExpr_env_types_map(t *testing.T) {\n\tenvTypes := types.Map{\n\t\t\"foo\": types.Map{\n\t\t\t\"bar\": types.String,\n\t\t},\n\t}\n\n\tprogram, err := expr.Compile(`foo.bar`, expr.Env(envTypes))\n\trequire.NoError(t, err)\n\n\tenv := map[string]any{\n\t\t\"foo\": map[string]any{\n\t\t\t\"bar\": \"value\",\n\t\t},\n\t}\n\n\toutput, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\trequire.Equal(t, \"value\", output)\n}\n\nfunc TestExpr_env_types_map_error(t *testing.T) {\n\tenvTypes := types.Map{\n\t\t\"foo\": types.Map{\n\t\t\t\"bar\": types.String,\n\t\t},\n\t}\n\n\tprogram, err := expr.Compile(`foo.bar`, expr.Env(envTypes))\n\trequire.NoError(t, err)\n\n\t_, err = expr.Run(program, envTypes)\n\trequire.Error(t, err)\n}\n\nfunc TestIssue758_filter_map_index(t *testing.T) {\n\tenv := map[string]interface{}{}\n\n\texprStr := `\n let a_map = 0..5 | filter(# % 2 == 0) | map(#index);\n let b_filter = 0..5 | filter(# % 2 == 0);\n let b_map = b_filter | map(#index);\n [a_map, b_map]\n `\n\n\tresult, err := expr.Eval(exprStr, env)\n\trequire.NoError(t, err)\n\n\texpected := []interface{}{\n\t\t[]interface{}{0, 1, 2},\n\t\t[]interface{}{0, 1, 2},\n\t}\n\n\trequire.Equal(t, expected, result)\n}\n\nfunc TestExpr_wierd_cases(t *testing.T) {\n\tenv := map[string]any{}\n\n\t_, err := expr.Compile(`A(A)`, expr.Env(env))\n\trequire.Error(t, err)\n\trequire.Contains(t, err.Error(), \"unknown name A\")\n}\n\nfunc TestIssue785_get_nil(t *testing.T) {\n\texprStrs := []string{\n\t\t`get(nil, \"a\")`,\n\t\t`get({}, \"a\")`,\n\t\t`get(nil, \"a\")`,\n\t\t`get({}, \"a\")`,\n\t\t`({} | get(\"a\") | get(\"b\"))`,\n\t}\n\n\tfor _, exprStr := range exprStrs {\n\t\tt.Run(\"get returns nil\", func(t *testing.T) {\n\t\t\tenv := map[string]interface{}{}\n\n\t\t\tresult, err := expr.Eval(exprStr, env)\n\t\t\trequire.NoError(t, err)\n\n\t\t\trequire.Equal(t, nil, result)\n\t\t})\n\t}\n}\n\nfunc TestMaxNodes(t *testing.T) {\n\tmaxNodes := uint(100)\n\n\tcode := \"\"\n\tfor i := 0; i < int(maxNodes); i++ {\n\t\tcode += \"1; \"\n\t}\n\n\t_, err := expr.Compile(code, expr.MaxNodes(maxNodes))\n\trequire.Error(t, err)\n\tassert.Contains(t, err.Error(), \"exceeds maximum allowed nodes\")\n\n\t_, err = expr.Compile(code, expr.MaxNodes(maxNodes+1))\n\trequire.NoError(t, err)\n}\n\nfunc TestMaxNodesDisabled(t *testing.T) {\n\tcode := \"\"\n\tfor i := 0; i < 2*int(conf.DefaultMaxNodes); i++ {\n\t\tcode += \"1; \"\n\t}\n\n\t_, err := expr.Compile(code, expr.MaxNodes(0))\n\trequire.NoError(t, err)\n}\n\nfunc TestMemoryBudget(t *testing.T) {\n\ttests := []struct {\n\t\tcode string\n\t\tmax int\n\t}{\n\t\t{`map(1..100, {map(1..100, {map(1..100, {0})})})`, -1},\n\t\t{`len(1..10000000)`, -1},\n\t\t{`1..100`, 100},\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.code)\n\t\t\trequire.NoError(t, err, \"compile error\")\n\n\t\t\tvm := vm.VM{}\n\t\t\tif tt.max > 0 {\n\t\t\t\tvm.MemoryBudget = uint(tt.max)\n\t\t\t}\n\t\t\t_, err = vm.Run(program, nil)\n\t\t\trequire.Error(t, err, \"run error\")\n\t\t\tassert.Contains(t, err.Error(), \"memory budget exceeded\")\n\t\t})\n\t}\n}\n\nfunc TestIssue802(t *testing.T) {\n\tprog, err := expr.Compile(`arr[1:2][0]`)\n\tif err != nil {\n\t\tt.Fatalf(\"error compiling program: %v\", err)\n\t}\n\tval, err := expr.Run(prog, map[string]any{\n\t\t\"arr\": [5]int{0, 1, 2, 3, 4},\n\t})\n\tif err != nil {\n\t\tt.Fatalf(\"error running program: %v\", err)\n\t}\n\tvalInt, ok := val.(int)\n\tif !ok || valInt != 1 {\n\t\tt.Fatalf(\"invalid result, expected 1, got %v\", val)\n\t}\n}\n\nfunc TestIssue807(t *testing.T) {\n\ttype MyStruct struct {\n\t\tnonExported string\n\t}\n\tout, err := expr.Eval(` \"nonExported\" in $env `, MyStruct{})\n\tif err != nil {\n\t\tt.Fatalf(\"unexpected error: %v\", err)\n\t}\n\tb, ok := out.(bool)\n\tif !ok {\n\t\tt.Fatalf(\"expected boolean type, got %T: %v\", b, b)\n\t}\n\tif b {\n\t\tt.Fatalf(\"expected 'in' operator to return false for unexported field\")\n\t}\n}\n\nfunc TestDisableShortCircuit(t *testing.T) {\n\tcount := 0\n\texprStr := \"foo() or bar()\"\n\tenv := map[string]any{\n\t\t\"foo\": func() bool {\n\t\t\tcount++\n\t\t\treturn true\n\t\t},\n\t\t\"bar\": func() bool {\n\t\t\tcount++\n\t\t\treturn true\n\t\t},\n\t}\n\n\tprogram, _ := expr.Compile(exprStr, expr.DisableShortCircuit())\n\tgot, _ := expr.Run(program, env)\n\tassert.Equal(t, 2, count)\n\tassert.True(t, got.(bool))\n\n\tprogram, _ = expr.Compile(exprStr)\n\tgot, _ = expr.Run(program, env)\n\tassert.Equal(t, 3, count)\n\tassert.True(t, got.(bool))\n}\n\nfunc TestBytesLiteral(t *testing.T) {\n\ttests := []struct {\n\t\tcode string\n\t\twant []byte\n\t}{\n\t\t{`b\"hello\"`, []byte(\"hello\")},\n\t\t{`b'world'`, []byte(\"world\")},\n\t\t{`b\"\"`, []byte{}},\n\t\t{`b'\\x00\\xff'`, []byte{0, 255}},\n\t\t{`b\"\\x41\\x42\\x43\"`, []byte(\"ABC\")},\n\t\t{`b'\\101\\102\\103'`, []byte(\"ABC\")},\n\t\t{`b'\\n\\t\\r'`, []byte{'\\n', '\\t', '\\r'}},\n\t\t{`b'hello\\x00world'`, []byte(\"hello\\x00world\")},\n\t\t{`b\"ÿ\"`, []byte{0xc3, 0xbf}}, // UTF-8 encoding of ÿ\n\t}\n\n\tfor _, tt := range tests {\n\t\tt.Run(tt.code, func(t *testing.T) {\n\t\t\tprogram, err := expr.Compile(tt.code)\n\t\t\trequire.NoError(t, err)\n\n\t\t\toutput, err := expr.Run(program, nil)\n\t\t\trequire.NoError(t, err)\n\t\t\tassert.Equal(t, tt.want, output)\n\t\t})\n\t}\n}\n\nfunc TestBytesLiteral_type(t *testing.T) {\n\tenv := map[string]any{\n\t\t\"data\": []byte(\"test\"),\n\t}\n\n\t// Verify bytes literal has []byte type and can be compared with []byte\n\tprogram, err := expr.Compile(`data == b\"test\"`, expr.Env(env))\n\trequire.NoError(t, err)\n\n\toutput, err := expr.Run(program, env)\n\trequire.NoError(t, err)\n\tassert.Equal(t, true, output)\n}\n\nfunc TestBytesLiteral_errors(t *testing.T) {\n\t// \\u and \\U escapes should not be allowed in bytes literals\n\terrorCases := []string{\n\t\t`b'\\u0041'`,\n\t\t`b\"\\U00000041\"`,\n\t}\n\n\tfor _, code := range errorCases {\n\t\tt.Run(code, func(t *testing.T) {\n\t\t\t_, err := expr.Compile(code)\n\t\t\trequire.Error(t, err)\n\t\t})\n\t}\n}\n"
},
{
"path": "file/error.go",
"content": "package file\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n)\n\ntype Error struct {\n\tLocation\n\tLine int `json:\"line\"`\n\tColumn int `json:\"column\"`\n\tMessage string `json:\"message\"`\n\tSnippet string `json:\"snippet\"`\n\tPrev error `json:\"prev\"`\n}\n\nfunc (e *Error) Error() string {\n\treturn e.format()\n}\n\nvar tabReplacer = strings.NewReplacer(\"\\t\", \" \")\n\nfunc (e *Error) Bind(source Source) *Error {\n\tsrc := source.String()\n\n\tvar runeCount, lineStart int\n\te.Line = 1\n\te.Column = 0\n\tfor i, r := range src {\n\t\tif runeCount == e.From {\n\t\t\tbreak\n\t\t}\n\t\tif r == '\\n' {\n\t\t\tlineStart = i + 1\n\t\t\te.Line++\n\t\t\te.Column = 0\n\t\t} else {\n\t\t\te.Column++\n\t\t}\n\t\truneCount++\n\t}\n\n\tlineEnd := lineStart + strings.IndexByte(src[lineStart:], '\\n')\n\tif lineEnd < lineStart {\n\t\tlineEnd = len(src)\n\t}\n\tif lineStart == lineEnd {\n\t\treturn e\n\t}\n\n\tconst prefix = \"\\n | \"\n\tline := src[lineStart:lineEnd]\n\tsnippet := new(strings.Builder)\n\tsnippet.Grow(2*len(prefix) + len(line) + e.Column + 1)\n\tsnippet.WriteString(prefix)\n\ttabReplacer.WriteString(snippet, line)\n\tsnippet.WriteString(prefix)\n\tfor i := 0; i < e.Column; i++ {\n\t\tsnippet.WriteByte('.')\n\t}\n\tsnippet.WriteByte('^')\n\te.Snippet = snippet.String()\n\treturn e\n}\n\nfunc (e *Error) Unwrap() error {\n\treturn e.Prev\n}\n\nfunc (e *Error) Wrap(err error) {\n\te.Prev = err\n}\n\nfunc (e *Error) format() string {\n\tif e.Snippet == \"\" {\n\t\treturn e.Message\n\t}\n\treturn fmt.Sprintf(\n\t\t\"%s (%d:%d)%s\",\n\t\te.Message,\n\t\te.Line,\n\t\te.Column+1, // add one to the 0-based column for display\n\t\te.Snippet,\n\t)\n}\n"
},
{
"path": "file/location.go",
"content": "package file\n\ntype Location struct {\n\tFrom int `json:\"from\"`\n\tTo int `json:\"to\"`\n}\n"
},
{
"path": "file/source.go",
"content": "package file\n\nimport \"strings\"\n\ntype Source struct {\n\traw string\n}\n\nfunc NewSource(contents string) Source {\n\treturn Source{\n\t\traw: contents,\n\t}\n}\n\nfunc (s Source) String() string {\n\treturn s.raw\n}\n\nfunc (s Source) Snippet(line int) (string, bool) {\n\tif s.raw == \"\" {\n\t\treturn \"\", false\n\t}\n\tvar start int\n\tfor i := 1; i < line; i++ {\n\t\tpos := strings.IndexByte(s.raw[start:], '\\n')\n\t\tif pos < 0 {\n\t\t\treturn \"\", false\n\t\t}\n\t\tstart += pos + 1\n\t}\n\tend := start + strings.IndexByte(s.raw[start:], '\\n')\n\tif end < start {\n\t\tend = len(s.raw)\n\t}\n\treturn s.raw[start:end], true\n}\n"
},
{
"path": "file/source_test.go",
"content": "package file\n\nimport (\n\t\"testing\"\n)\n\nconst (\n\tunexpectedSnippet = \"%s got snippet '%s', want '%v'\"\n\tsnippetNotFound = \"%s snippet not found, wanted '%v'\"\n\tsnippetFound = \"%s snippet found at Line %d, wanted none\"\n)\n\nfunc TestStringSource_SnippetMultiLine(t *testing.T) {\n\tsource := NewSource(\"hello\\nworld\\nmy\\nbub\\n\")\n\tif str, found := source.Snippet(1); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 1)\n\t} else if str != \"hello\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str, \"hello\")\n\t}\n\tif str2, found := source.Snippet(2); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 2)\n\t} else if str2 != \"world\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str2, \"world\")\n\t}\n\tif str3, found := source.Snippet(3); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 3)\n\t} else if str3 != \"my\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str3, \"my\")\n\t}\n\tif str4, found := source.Snippet(4); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 4)\n\t} else if str4 != \"bub\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str4, \"bub\")\n\t}\n\tif str5, found := source.Snippet(5); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 5)\n\t} else if str5 != \"\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str5, \"\")\n\t}\n}\n\nfunc TestStringSource_SnippetSingleLine(t *testing.T) {\n\tsource := NewSource(\"hello, world\")\n\tif str, found := source.Snippet(1); !found {\n\t\tt.Errorf(snippetNotFound, t.Name(), 1)\n\t} else if str != \"hello, world\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str, \"hello, world\")\n\t}\n\tif str2, found := source.Snippet(2); found {\n\t\tt.Errorf(snippetFound, t.Name(), 2)\n\t} else if str2 != \"\" {\n\t\tt.Errorf(unexpectedSnippet, t.Name(), str2, \"\")\n\t}\n}\n"
},
{
"path": "go.mod",
"content": "module github.com/expr-lang/expr\n\ngo 1.18\n"
},
{
"path": "internal/deref/deref.go",
"content": "package deref\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n)\n\nfunc Interface(p any) any {\n\tif p == nil {\n\t\treturn nil\n\t}\n\n\tv := reflect.ValueOf(p)\n\n\tfor v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {\n\t\tif v.IsNil() {\n\t\t\treturn nil\n\t\t}\n\t\tv = v.Elem()\n\t}\n\n\tif v.IsValid() {\n\t\treturn v.Interface()\n\t}\n\n\tpanic(fmt.Sprintf(\"cannot dereference %v\", p))\n}\n\nfunc Type(t reflect.Type) reflect.Type {\n\tif t == nil {\n\t\treturn nil\n\t}\n\tfor t.Kind() == reflect.Ptr {\n\t\tt = t.Elem()\n\t}\n\treturn t\n}\n\nfunc Value(v reflect.Value) reflect.Value {\n\tfor v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {\n\t\tif v.IsNil() {\n\t\t\treturn v\n\t\t}\n\t\tv = v.Elem()\n\t}\n\treturn v\n}\n\nfunc TypeKind(t reflect.Type, k reflect.Kind) (_ reflect.Type, _ reflect.Kind, changed bool) {\n\tfor k == reflect.Pointer {\n\t\tchanged = true\n\t\tt = t.Elem()\n\t\tk = t.Kind()\n\t}\n\treturn t, k, changed\n}\n"
},
{
"path": "internal/deref/deref_test.go",
"content": "package deref_test\n\nimport (\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/expr-lang/expr/internal/testify/assert\"\n\n\t\"github.com/expr-lang/expr/internal/deref\"\n)\n\nfunc TestDeref(t *testing.T) {\n\ta := uint(42)\n\tb := &a\n\tc := &b\n\td := &c\n\n\tgot := deref.Interface(d)\n\tassert.Equal(t, uint(42), got)\n}\n\nfunc TestDeref_mix_ptr_with_interface(t *testing.T) {\n\ta := uint(42)\n\tvar b any = &a\n\tvar c any = &b\n\td := &c\n\n\tgot := deref.Interface(d)\n\tassert.Equal(t, uint(42), got)\n}\n\nfunc TestDeref_nil(t *testing.T) {\n\tvar a *int\n\tassert.Nil(t, deref.Interface(a))\n\tassert.Nil(t, deref.Interface(nil))\n}\n\nfunc TestType(t *testing.T) {\n\ta := uint(42)\n\tb := &a\n\tc := &b\n\td := &c\n\n\tdt := deref.Type(reflect.TypeOf(d))\n\tassert.Equal(t, reflect.Uint, dt.Kind())\n}\n\nfunc TestType_two_ptr_with_interface(t *testing.T) {\n\ta := uint(42)\n\tvar b any = &a\n\n\tdt := deref.Type(reflect.TypeOf(b))\n\tassert.Equal(t, reflect.Uint, dt.Kind())\n\n}\n\nfunc TestType_three_ptr_with_interface(t *testing.T) {\n\ta := uint(42)\n\tvar b any = &a\n\tvar c any = &b\n\n\tdt := deref.Type(reflect.TypeOf(c))\n\tassert.Equal(t, reflect.Interface, dt.Kind())\n}\n\nfunc TestType_nil(t *testing.T) {\n\tassert.Nil(t, deref.Type(nil))\n}\n\nfunc TestValue(t *testing.T) {\n\ta := uint(42)\n\tb := &a\n\tc := &b\n\td := &c\n\n\tgot := deref.Value(reflect.ValueOf(d))\n\tassert.Equal(t, uint(42), got.Interface())\n}\n\nfunc TestValue_two_ptr_with_interface(t *testing.T) {\n\ta := uint(42)\n\tvar b any = &a\n\n\tgot := deref.Value(reflect.ValueOf(b))\n\tassert.Equal(t, uint(42), got.Interface())\n}\n\nfunc TestValue_three_ptr_with_interface(t *testing.T) {\n\ta := uint(42)\n\tvar b any = &a\n\tc := &b\n\n\tgot := deref.Value(reflect.ValueOf(c))\n\tassert.Equal(t, uint(42), got.Interface())\n}\n\nfunc TestValue_nil(t *testing.T) {\n\tgot := deref.Value(reflect.ValueOf(nil))\n\tassert.False(t, got.IsValid())\n}\n\nfunc TestValue_nil_in_chain(t *testing.T) {\n\tvar a any = nil\n\tvar b any = &a\n\tc := &b\n\n\tgot := deref.Value(reflect.ValueOf(c))\n\tassert.True(t, got.IsValid())\n\tassert.True(t, got.IsNil())\n\tassert.Nil(t, got.Interface())\n}\n"
},
{
"path": "internal/difflib/difflib.go",
"content": "// Package difflib is a partial port of Python difflib module.\n//\n// It provides tools to compare sequences of strings and generate textual diffs.\n//\n// The following class and functions have been ported:\n//\n// - SequenceMatcher\n//\n// - unified_diff\n//\n// - context_diff\n//\n// Getting unified diffs was the main goal of the port. Keep in mind this code\n// is mostly suitable to output text differences in a human friendly way, there\n// are no guarantees generated diffs are consumable by patch(1).\npackage difflib\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n)\n\nfunc min(a, b int) int {\n\tif a < b {\n\t\treturn a\n\t}\n\treturn b\n}\n\nfunc max(a, b int) int {\n\tif a > b {\n\t\treturn a\n\t}\n\treturn b\n}\n\nfunc calculateRatio(matches, length int) float64 {\n\tif length > 0 {\n\t\treturn 2.0 * float64(matches) / float64(length)\n\t}\n\treturn 1.0\n}\n\ntype Match struct {\n\tA int\n\tB int\n\tSize int\n}\n\ntype OpCode struct {\n\tTag byte\n\tI1 int\n\tI2 int\n\tJ1 int\n\tJ2 int\n}\n\n// SequenceMatcher compares sequence of strings. The basic\n// algorithm predates, and is a little fancier than, an algorithm\n// published in the late 1980's by Ratcliff and Obershelp under the\n// hyperbolic name \"gestalt pattern matching\". The basic idea is to find\n// the longest contiguous matching subsequence that contains no \"junk\"\n// elements (R-O doesn't address junk). The same idea is then applied\n// recursively to the pieces of the sequences to the left and to the right\n// of the matching subsequence. This does not yield minimal edit\n// sequences, but does tend to yield matches that \"look right\" to people.\n//\n// SequenceMatcher tries to compute a \"human-friendly diff\" between two\n// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the\n// longest *contiguous* & junk-free matching subsequence. That's what\n// catches peoples' eyes. The Windows(tm) windiff has another interesting\n// notion, pairing up elements that appear uniquely in each sequence.\n// That, and the method here, appear to yield more intuitive difference\n// reports than does diff. This method appears to be the least vulnerable\n// to synching up on blocks of \"junk lines\", though (like blank lines in\n// ordinary text files, or maybe \"\" lines in HTML files). That may be\n// because this is the only method of the 3 that has a *concept* of\n// \"junk\" .\n//\n// Timing: Basic R-O is cubic time worst case and quadratic time expected\n// case. SequenceMatcher is quadratic time for the worst case and has\n// expected-case behavior dependent in a complicated way on how many\n// elements the sequences have in common; best case time is linear.\ntype SequenceMatcher struct {\n\ta []string\n\tb []string\n\tb2j map[string][]int\n\tIsJunk func(string) bool\n\tautoJunk bool\n\tbJunk map[string]struct{}\n\tmatchingBlocks []Match\n\tfullBCount map[string]int\n\tbPopular map[string]struct{}\n\topCodes []OpCode\n}\n\nfunc NewMatcher(a, b []string) *SequenceMatcher {\n\tm := SequenceMatcher{autoJunk: true}\n\tm.SetSeqs(a, b)\n\treturn &m\n}\n\nfunc NewMatcherWithJunk(a, b []string, autoJunk bool,\n\tisJunk func(string) bool) *SequenceMatcher {\n\n\tm := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}\n\tm.SetSeqs(a, b)\n\treturn &m\n}\n\n// Set two sequences to be compared.\nfunc (m *SequenceMatcher) SetSeqs(a, b []string) {\n\tm.SetSeq1(a)\n\tm.SetSeq2(b)\n}\n\n// Set the first sequence to be compared. The second sequence to be compared is\n// not changed.\n//\n// SequenceMatcher computes and caches detailed information about the second\n// sequence, so if you want to compare one sequence S against many sequences,\n// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other\n// sequences.\n//\n// See also SetSeqs() and SetSeq2().\nfunc (m *SequenceMatcher) SetSeq1(a []string) {\n\tif &a == &m.a {\n\t\treturn\n\t}\n\tm.a = a\n\tm.matchingBlocks = nil\n\tm.opCodes = nil\n}\n\n// Set the second sequence to be compared. The first sequence to be compared is\n// not changed.\nfunc (m *SequenceMatcher) SetSeq2(b []string) {\n\tif &b == &m.b {\n\t\treturn\n\t}\n\tm.b = b\n\tm.matchingBlocks = nil\n\tm.opCodes = nil\n\tm.fullBCount = nil\n\tm.chainB()\n}\n\nfunc (m *SequenceMatcher) chainB() {\n\t// Populate line -> index mapping\n\tb2j := map[string][]int{}\n\tfor i, s := range m.b {\n\t\tindices := b2j[s]\n\t\tindices = append(indices, i)\n\t\tb2j[s] = indices\n\t}\n\n\t// Purge junk elements\n\tm.bJunk = map[string]struct{}{}\n\tif m.IsJunk != nil {\n\t\tjunk := m.bJunk\n\t\tfor s, _ := range b2j {\n\t\t\tif m.IsJunk(s) {\n\t\t\t\tjunk[s] = struct{}{}\n\t\t\t}\n\t\t}\n\t\tfor s, _ := range junk {\n\t\t\tdelete(b2j, s)\n\t\t}\n\t}\n\n\t// Purge remaining popular elements\n\tpopular := map[string]struct{}{}\n\tn := len(m.b)\n\tif m.autoJunk && n >= 200 {\n\t\tntest := n/100 + 1\n\t\tfor s, indices := range b2j {\n\t\t\tif len(indices) > ntest {\n\t\t\t\tpopular[s] = struct{}{}\n\t\t\t}\n\t\t}\n\t\tfor s, _ := range popular {\n\t\t\tdelete(b2j, s)\n\t\t}\n\t}\n\tm.bPopular = popular\n\tm.b2j = b2j\n}\n\nfunc (m *SequenceMatcher) isBJunk(s string) bool {\n\t_, ok := m.bJunk[s]\n\treturn ok\n}\n\n// Find longest matching block in a[alo:ahi] and b[blo:bhi].\n//\n// If IsJunk is not defined:\n//\n// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where\n//\n//\talo <= i <= i+k <= ahi\n//\tblo <= j <= j+k <= bhi\n//\n// and for all (i',j',k') meeting those conditions,\n//\n//\tk >= k'\n//\ti <= i'\n//\tand if i == i', j <= j'\n//\n// In other words, of all maximal matching blocks, return one that\n// starts earliest in a, and of all those maximal matching blocks that\n// start earliest in a, return the one that starts earliest in b.\n//\n// If IsJunk is defined, first the longest matching block is\n// determined as above, but with the additional restriction that no\n// junk element appears in the block. Then that block is extended as\n// far as possible by matching (only) junk elements on both sides. So\n// the resulting block never matches on junk except as identical junk\n// happens to be adjacent to an \"interesting\" match.\n//\n// If no blocks match, return (alo, blo, 0).\nfunc (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {\n\t// CAUTION: stripping common prefix or suffix would be incorrect.\n\t// E.g.,\n\t// ab\n\t// acab\n\t// Longest matching block is \"ab\", but if common prefix is\n\t// stripped, it's \"a\" (tied with \"b\"). UNIX(tm) diff does so\n\t// strip, so ends up claiming that ab is changed to acab by\n\t// inserting \"ca\" in the middle. That's minimal but unintuitive:\n\t// \"it's obvious\" that someone inserted \"ac\" at the front.\n\t// Windiff ends up at the same place as diff, but by pairing up\n\t// the unique 'b's and then matching the first two 'a's.\n\tbesti, bestj, bestsize := alo, blo, 0\n\n\t// find longest junk-free match\n\t// during an iteration of the loop, j2len[j] = length of longest\n\t// junk-free match ending with a[i-1] and b[j]\n\tj2len := map[int]int{}\n\tfor i := alo; i != ahi; i++ {\n\t\t// look at all instances of a[i] in b; note that because\n\t\t// b2j has no junk keys, the loop is skipped if a[i] is junk\n\t\tnewj2len := map[int]int{}\n\t\tfor _, j := range m.b2j[m.a[i]] {\n\t\t\t// a[i] matches b[j]\n\t\t\tif j < blo {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif j >= bhi {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tk := j2len[j-1] + 1\n\t\t\tnewj2len[j] = k\n\t\t\tif k > bestsize {\n\t\t\t\tbesti, bestj, bestsize = i-k+1, j-k+1, k\n\t\t\t}\n\t\t}\n\t\tj2len = newj2len\n\t}\n\n\t// Extend the best by non-junk elements on each end. In particular,\n\t// \"popular\" non-junk elements aren't in b2j, which greatly speeds\n\t// the inner loop above, but also means \"the best\" match so far\n\t// doesn't contain any junk *or* popular non-junk elements.\n\tfor besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&\n\t\tm.a[besti-1] == m.b[bestj-1] {\n\t\tbesti, bestj, bestsize = besti-1, bestj-1, bestsize+1\n\t}\n\tfor besti+bestsize < ahi && bestj+bestsize < bhi &&\n\t\t!m.isBJunk(m.b[bestj+bestsize]) &&\n\t\tm.a[besti+bestsize] == m.b[bestj+bestsize] {\n\t\tbestsize += 1\n\t}\n\n\t// Now that we have a wholly interesting match (albeit possibly\n\t// empty!), we may as well suck up the matching junk on each\n\t// side of it too. Can't think of a good reason not to, and it\n\t// saves post-processing the (possibly considerable) expense of\n\t// figuring out what to do with it. In the case of an empty\n\t// interesting match, this is clearly the right thing to do,\n\t// because no other kind of match is possible in the regions.\n\tfor besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&\n\t\tm.a[besti-1] == m.b[bestj-1] {\n\t\tbesti, bestj, bestsize = besti-1, bestj-1, bestsize+1\n\t}\n\tfor besti+bestsize < ahi && bestj+bestsize < bhi &&\n\t\tm.isBJunk(m.b[bestj+bestsize]) &&\n\t\tm.a[besti+bestsize] == m.b[bestj+bestsize] {\n\t\tbestsize += 1\n\t}\n\n\treturn Match{A: besti, B: bestj, Size: bestsize}\n}\n\n// Return list of triples describing matching subsequences.\n//\n// Each triple is of the form (i, j, n), and means that\n// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in\n// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are\n// adjacent triples in the list, and the second is not the last triple in the\n// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe\n// adjacent equal blocks.\n//\n// The last triple is a dummy, (len(a), len(b), 0), and is the only\n// triple with n==0.\nfunc (m *SequenceMatcher) GetMatchingBlocks() []Match {\n\tif m.matchingBlocks != nil {\n\t\treturn m.matchingBlocks\n\t}\n\n\tvar matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match\n\tmatchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {\n\t\tmatch := m.findLongestMatch(alo, ahi, blo, bhi)\n\t\ti, j, k := match.A, match.B, match.Size\n\t\tif match.Size > 0 {\n\t\t\tif alo < i && blo < j {\n\t\t\t\tmatched = matchBlocks(alo, i, blo, j, matched)\n\t\t\t}\n\t\t\tmatched = append(matched, match)\n\t\t\tif i+k < ahi && j+k < bhi {\n\t\t\t\tmatched = matchBlocks(i+k, ahi, j+k, bhi, matched)\n\t\t\t}\n\t\t}\n\t\treturn matched\n\t}\n\tmatched := matchBlocks(0, len(m.a), 0, len(m.b), nil)\n\n\t// It's possible that we have adjacent equal blocks in the\n\t// matching_blocks list now.\n\tnonAdjacent := []Match{}\n\ti1, j1, k1 := 0, 0, 0\n\tfor _, b := range matched {\n\t\t// Is this block adjacent to i1, j1, k1?\n\t\ti2, j2, k2 := b.A, b.B, b.Size\n\t\tif i1+k1 == i2 && j1+k1 == j2 {\n\t\t\t// Yes, so collapse them -- this just increases the length of\n\t\t\t// the first block by the length of the second, and the first\n\t\t\t// block so lengthened remains the block to compare against.\n\t\t\tk1 += k2\n\t\t} else {\n\t\t\t// Not adjacent. Remember the first block (k1==0 means it's\n\t\t\t// the dummy we started with), and make the second block the\n\t\t\t// new block to compare against.\n\t\t\tif k1 > 0 {\n\t\t\t\tnonAdjacent = append(nonAdjacent, Match{i1, j1, k1})\n\t\t\t}\n\t\t\ti1, j1, k1 = i2, j2, k2\n\t\t}\n\t}\n\tif k1 > 0 {\n\t\tnonAdjacent = append(nonAdjacent, Match{i1, j1, k1})\n\t}\n\n\tnonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})\n\tm.matchingBlocks = nonAdjacent\n\treturn m.matchingBlocks\n}\n\n// Return list of 5-tuples describing how to turn a into b.\n//\n// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple\n// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the\n// tuple preceding it, and likewise for j1 == the previous j2.\n//\n// The tags are characters, with these meanings:\n//\n// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]\n//\n// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.\n//\n// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.\n//\n// 'e' (equal): a[i1:i2] == b[j1:j2]\nfunc (m *SequenceMatcher) GetOpCodes() []OpCode {\n\tif m.opCodes != nil {\n\t\treturn m.opCodes\n\t}\n\ti, j := 0, 0\n\tmatching := m.GetMatchingBlocks()\n\topCodes := make([]OpCode, 0, len(matching))\n\tfor _, m := range matching {\n\t\t// invariant: we've pumped out correct diffs to change\n\t\t// a[:i] into b[:j], and the next matching block is\n\t\t// a[ai:ai+size] == b[bj:bj+size]. So we need to pump\n\t\t// out a diff to change a[i:ai] into b[j:bj], pump out\n\t\t// the matching block, and move (i,j) beyond the match\n\t\tai, bj, size := m.A, m.B, m.Size\n\t\ttag := byte(0)\n\t\tif i < ai && j < bj {\n\t\t\ttag = 'r'\n\t\t} else if i < ai {\n\t\t\ttag = 'd'\n\t\t} else if j < bj {\n\t\t\ttag = 'i'\n\t\t}\n\t\tif tag > 0 {\n\t\t\topCodes = append(opCodes, OpCode{tag, i, ai, j, bj})\n\t\t}\n\t\ti, j = ai+size, bj+size\n\t\t// the list of matching blocks is terminated by a\n\t\t// sentinel with size 0\n\t\tif size > 0 {\n\t\t\topCodes = append(opCodes, OpCode{'e', ai, i, bj, j})\n\t\t}\n\t}\n\tm.opCodes = opCodes\n\treturn m.opCodes\n}\n\n// Isolate change clusters by eliminating ranges with no changes.\n//\n// Return a generator of groups with up to n lines of context.\n// Each group is in the same format as returned by GetOpCodes().\nfunc (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {\n\tif n < 0 {\n\t\tn = 3\n\t}\n\tcodes := m.GetOpCodes()\n\tif len(codes) == 0 {\n\t\tcodes = []OpCode{OpCode{'e', 0, 1, 0, 1}}\n\t}\n\t// Fixup leading and trailing groups if they show no changes.\n\tif codes[0].Tag == 'e' {\n\t\tc := codes[0]\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\tcodes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}\n\t}\n\tif codes[len(codes)-1].Tag == 'e' {\n\t\tc := codes[len(codes)-1]\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\tcodes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}\n\t}\n\tnn := n + n\n\tgroups := [][]OpCode{}\n\tgroup := []OpCode{}\n\tfor _, c := range codes {\n\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\t// End the current group and start a new one whenever\n\t\t// there is a large range with no changes.\n\t\tif c.Tag == 'e' && i2-i1 > nn {\n\t\t\tgroup = append(group, OpCode{c.Tag, i1, min(i2, i1+n),\n\t\t\t\tj1, min(j2, j1+n)})\n\t\t\tgroups = append(groups, group)\n\t\t\tgroup = []OpCode{}\n\t\t\ti1, j1 = max(i1, i2-n), max(j1, j2-n)\n\t\t}\n\t\tgroup = append(group, OpCode{c.Tag, i1, i2, j1, j2})\n\t}\n\tif len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {\n\t\tgroups = append(groups, group)\n\t}\n\treturn groups\n}\n\n// Return a measure of the sequences' similarity (float in [0,1]).\n//\n// Where T is the total number of elements in both sequences, and\n// M is the number of matches, this is 2.0*M / T.\n// Note that this is 1 if the sequences are identical, and 0 if\n// they have nothing in common.\n//\n// .Ratio() is expensive to compute if you haven't already computed\n// .GetMatchingBlocks() or .GetOpCodes(), in which case you may\n// want to try .QuickRatio() or .RealQuickRation() first to get an\n// upper bound.\nfunc (m *SequenceMatcher) Ratio() float64 {\n\tmatches := 0\n\tfor _, m := range m.GetMatchingBlocks() {\n\t\tmatches += m.Size\n\t}\n\treturn calculateRatio(matches, len(m.a)+len(m.b))\n}\n\n// Return an upper bound on ratio() relatively quickly.\n//\n// This isn't defined beyond that it is an upper bound on .Ratio(), and\n// is faster to compute.\nfunc (m *SequenceMatcher) QuickRatio() float64 {\n\t// viewing a and b as multisets, set matches to the cardinality\n\t// of their intersection; this counts the number of matches\n\t// without regard to order, so is clearly an upper bound\n\tif m.fullBCount == nil {\n\t\tm.fullBCount = map[string]int{}\n\t\tfor _, s := range m.b {\n\t\t\tm.fullBCount[s] = m.fullBCount[s] + 1\n\t\t}\n\t}\n\n\t// avail[x] is the number of times x appears in 'b' less the\n\t// number of times we've seen it in 'a' so far ... kinda\n\tavail := map[string]int{}\n\tmatches := 0\n\tfor _, s := range m.a {\n\t\tn, ok := avail[s]\n\t\tif !ok {\n\t\t\tn = m.fullBCount[s]\n\t\t}\n\t\tavail[s] = n - 1\n\t\tif n > 0 {\n\t\t\tmatches += 1\n\t\t}\n\t}\n\treturn calculateRatio(matches, len(m.a)+len(m.b))\n}\n\n// Return an upper bound on ratio() very quickly.\n//\n// This isn't defined beyond that it is an upper bound on .Ratio(), and\n// is faster to compute than either .Ratio() or .QuickRatio().\nfunc (m *SequenceMatcher) RealQuickRatio() float64 {\n\tla, lb := len(m.a), len(m.b)\n\treturn calculateRatio(min(la, lb), la+lb)\n}\n\n// Convert range to the \"ed\" format\nfunc formatRangeUnified(start, stop int) string {\n\t// Per the diff spec at http://www.unix.org/single_unix_specification/\n\tbeginning := start + 1 // lines start numbering with one\n\tlength := stop - start\n\tif length == 1 {\n\t\treturn fmt.Sprintf(\"%d\", beginning)\n\t}\n\tif length == 0 {\n\t\tbeginning -= 1 // empty ranges begin at line just before the range\n\t}\n\treturn fmt.Sprintf(\"%d,%d\", beginning, length)\n}\n\n// Unified diff parameters\ntype UnifiedDiff struct {\n\tA []string // First sequence lines\n\tFromFile string // First file name\n\tFromDate string // First file time\n\tB []string // Second sequence lines\n\tToFile string // Second file name\n\tToDate string // Second file time\n\tEol string // Headers end of line, defaults to LF\n\tContext int // Number of context lines\n}\n\n// Compare two sequences of lines; generate the delta as a unified diff.\n//\n// Unified diffs are a compact way of showing line changes and a few\n// lines of context. The number of context lines is set by 'n' which\n// defaults to three.\n//\n// By default, the diff control lines (those with ---, +++, or @@) are\n// created with a trailing newline. This is helpful so that inputs\n// created from file.readlines() result in diffs that are suitable for\n// file.writelines() since both the inputs and outputs have trailing\n// newlines.\n//\n// For inputs that do not have trailing newlines, set the lineterm\n// argument to \"\" so that the output will be uniformly newline free.\n//\n// The unidiff format normally has a header for filenames and modification\n// times. Any or all of these may be specified using strings for\n// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.\n// The modification times are normally expressed in the ISO 8601 format.\nfunc WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {\n\tbuf := bufio.NewWriter(writer)\n\tdefer buf.Flush()\n\twf := func(format string, args ...interface{}) error {\n\t\t_, err := buf.WriteString(fmt.Sprintf(format, args...))\n\t\treturn err\n\t}\n\tws := func(s string) error {\n\t\t_, err := buf.WriteString(s)\n\t\treturn err\n\t}\n\n\tif len(diff.Eol) == 0 {\n\t\tdiff.Eol = \"\\n\"\n\t}\n\n\tstarted := false\n\tm := NewMatcher(diff.A, diff.B)\n\tfor _, g := range m.GetGroupedOpCodes(diff.Context) {\n\t\tif !started {\n\t\t\tstarted = true\n\t\t\tfromDate := \"\"\n\t\t\tif len(diff.FromDate) > 0 {\n\t\t\t\tfromDate = \"\\t\" + diff.FromDate\n\t\t\t}\n\t\t\ttoDate := \"\"\n\t\t\tif len(diff.ToDate) > 0 {\n\t\t\t\ttoDate = \"\\t\" + diff.ToDate\n\t\t\t}\n\t\t\tif diff.FromFile != \"\" || diff.ToFile != \"\" {\n\t\t\t\terr := wf(\"--- %s%s%s\", diff.FromFile, fromDate, diff.Eol)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\terr = wf(\"+++ %s%s%s\", diff.ToFile, toDate, diff.Eol)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfirst, last := g[0], g[len(g)-1]\n\t\trange1 := formatRangeUnified(first.I1, last.I2)\n\t\trange2 := formatRangeUnified(first.J1, last.J2)\n\t\tif err := wf(\"@@ -%s +%s @@%s\", range1, range2, diff.Eol); err != nil {\n\t\t\treturn err\n\t\t}\n\t\tfor _, c := range g {\n\t\t\ti1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2\n\t\t\tif c.Tag == 'e' {\n\t\t\t\tfor _, line := range diff.A[i1:i2] {\n\t\t\t\t\tif err := ws(\" \" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif c.Tag == 'r' || c.Tag == 'd' {\n\t\t\t\tfor _, line := range diff.A[i1:i2] {\n\t\t\t\t\tif err := ws(\"-\" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif c.Tag == 'r' || c.Tag == 'i' {\n\t\t\t\tfor _, line := range diff.B[j1:j2] {\n\t\t\t\t\tif err := ws(\"+\" + line); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn nil\n}\n\n// Like WriteUnifiedDiff but returns the diff a string.\nfunc GetUnifiedDiffString(diff UnifiedDiff) (string, error) {\n\tw := &bytes.Buffer{}\n\terr := WriteUnifiedDiff(w, diff)\n\treturn string(w.Bytes()), err\n}\n\n// Convert range to the \"ed\" format.\nfunc formatRangeContext(start, stop int) string {\n\t// Per the diff spec at http://www.unix.org/single_unix_specification/\n\tbeginning := start + 1 // lines start numbering with one\n\tlength := stop - start\n\tif length == 0 {\n\t\tbeginning -= 1 // empty ranges begin at line just before the range\n\t}\n\tif length <= 1 {\n\t\treturn fmt.Sprintf(\"%d\", beginning)\n\t}\n\treturn fmt.Sprintf(\"%d,%d\", beginning, beginning+length-1)\n}\n\ntype ContextDiff UnifiedDiff\n\n// Compare two sequences of lines; generate the delta as a context diff.\n//\n// Context diffs are a compact way of showing line changes and a few\n// lines of context. The number of context lines is set by diff.Context\n// which defaults to three.\n//\n// By default, the diff control lines (those with *** or ---) are\n// created with a trailing newline.\n//\n// For inputs that do not have trailing newlines, set the diff.Eol\n// argument to \"\" so that the output will be uniformly newline free.\n//\n// The context diff format normally has a header for filenames and\n// modification times. Any or all of these may be specified using\n// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.\n// The modification times are normally expressed in the ISO 8601 format.\n// If not specified, the strings default to blanks.\nfunc WriteContextDiff(writer io.Writer, diff ContextDiff) error {\n\tbuf := bufio.NewWriter(writer)\n\tdefer buf.Flush()\n\tvar diffErr error\n\twf := func(format string, args ...interface{}) {\n\t\t_, err := buf.WriteString(fmt.Sprintf(format, args...))\n\t\tif diffErr == nil && err != nil {\n\t\t\tdiffErr = err\n\t\t}\n\t}\n\tws := func(s string) {\n\t\t_, err := buf.WriteString(s)\n\t\tif diffErr == nil && err != nil {\n\t\t\tdiffErr = err\n\t\t}\n\t}\n\n\tif len(diff.Eol) == 0 {\n\t\tdiff.Eol = \"\\n\"\n\t}\n\n\tprefix := map[byte]string{\n\t\t'i': \"+ \",\n\t\t'd': \"- \",\n\t\t'r': \"! \",\n\t\t'e': \" \",\n\t}\n\n\tstarted := false\n\tm := NewMatcher(diff.A, diff.B)\n\tfor _, g := range m.GetGroupedOpCodes(diff.Context) {\n\t\tif !started {\n\t\t\tstarted = true\n\t\t\tfromDate := \"\"\n\t\t\tif len(diff.FromDate) > 0 {\n\t\t\t\tfromDate = \"\\t\" + diff.FromDate\n\t\t\t}\n\t\t\ttoDate := \"\"\n\t\t\tif len(diff.ToDate) > 0 {\n\t\t\t\ttoDate = \"\\t\" + diff.ToDate\n\t\t\t}\n\t\t\tif diff.FromFile != \"\" || diff.ToFile != \"\" {\n\t\t\t\twf(\"*** %s%s%s\", diff.FromFile, fromDate, diff.Eol)\n\t\t\t\twf(\"--- %s%s%s\", diff.ToFile, toDate, diff.Eol)\n\t\t\t}\n\t\t}\n\n\t\tfirst, last := g[0], g[len(g)-1]\n\t\tws(\"***************\" + diff.Eol)\n\n\t\trange1 := formatRangeContext(first.I1, last.I2)\n\t\twf(\"*** %s ****%s\", range1, diff.Eol)\n\t\tfor _, c := range g {\n\t\t\tif c.Tag == 'r' || c.Tag == 'd' {\n\t\t\t\tfor _, cc := range g {\n\t\t\t\t\tif cc.Tag == 'i' {\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t\tfor _, line := range diff.A[cc.I1:cc.I2] {\n\t\t\t\t\t\tws(prefix[cc.Tag] + line)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\n\t\trange2 := formatRangeContext(first.J1, last.J2)\n\t\twf(\"--- %s ----%s\", range2, diff.Eol)\n\t\tfor _, c := range g {\n\t\t\tif c.Tag == 'r' || c.Tag == 'i' {\n\t\t\t\tfor _, cc := range g {\n\t\t\t\t\tif cc.Tag == 'd' {\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t\tfor _, line := range diff.B[cc.J1:cc.J2] {\n\t\t\t\t\t\tws(prefix[cc.Tag] + line)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\treturn diffErr\n}\n\n// Like WriteContextDiff but returns the diff a string.\nfunc GetContextDiffString(diff ContextDiff) (string, error) {\n\tw := &bytes.Buffer{}\n\terr := WriteContextDiff(w, diff)\n\treturn string(w.Bytes()), err\n}\n\n// Split a string on \"\\n\" while preserving them. The output can be used\n// as input for UnifiedDiff and ContextDiff structures.\nfunc SplitLines(s string) []string {\n\tlines := strings.SplitAfter(s, \"\\n\")\n\tlines[len(lines)-1] += \"\\n\"\n\treturn lines\n}\n"
},
{
"path": "internal/difflib/difflib_test.go",
"content": "package difflib\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"math\"\n\t\"reflect\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc assertAlmostEqual(t *testing.T, a, b float64, places int) {\n\tif math.Abs(a-b) > math.Pow10(-places) {\n\t\tt.Errorf(\"%.7f != %.7f\", a, b)\n\t}\n}\n\nfunc assertEqual(t *testing.T, a, b interface{}) {\n\tif !reflect.DeepEqual(a, b) {\n\t\tt.Errorf(\"%v != %v\", a, b)\n\t}\n}\n\nfunc splitChars(s string) []string {\n\tchars := make([]string, 0, len(s))\n\t// Assume ASCII inputs\n\tfor i := 0; i != len(s); i++ {\n\t\tchars = append(chars, string(s[i]))\n\t}\n\treturn chars\n}\n\nfunc TestSequenceMatcherRatio(t *testing.T) {\n\ts := NewMatcher(splitChars(\"abcd\"), splitChars(\"bcde\"))\n\tassertEqual(t, s.Ratio(), 0.75)\n\tassertEqual(t, s.QuickRatio(), 0.75)\n\tassertEqual(t, s.RealQuickRatio(), 1.0)\n}\n\nfunc TestGetOptCodes(t *testing.T) {\n\ta := \"qabxcd\"\n\tb := \"abycdf\"\n\ts := NewMatcher(splitChars(a), splitChars(b))\n\tw := &bytes.Buffer{}\n\tfor _, op := range s.GetOpCodes() {\n\t\tfmt.Fprintf(w, \"%s a[%d:%d], (%s) b[%d:%d] (%s)\\n\", string(op.Tag),\n\t\t\top.I1, op.I2, a[op.I1:op.I2], op.J1, op.J2, b[op.J1:op.J2])\n\t}\n\tresult := string(w.Bytes())\n\texpected := `d a[0:1], (q) b[0:0] ()\ne a[1:3], (ab) b[0:2] (ab)\nr a[3:4], (x) b[2:3] (y)\ne a[4:6], (cd) b[3:5] (cd)\ni a[6:6], () b[5:6] (f)\n`\n\tif expected != result {\n\t\tt.Errorf(\"unexpected op codes: \\n%s\", result)\n\t}\n}\n\nfunc TestGroupedOpCodes(t *testing.T) {\n\ta := []string{}\n\tfor i := 0; i != 39; i++ {\n\t\ta = append(a, fmt.Sprintf(\"%02d\", i))\n\t}\n\tb := []string{}\n\tb = append(b, a[:8]...)\n\tb = append(b, \" i\")\n\tb = append(b, a[8:19]...)\n\tb = append(b, \" x\")\n\tb = append(b, a[20:22]...)\n\tb = append(b, a[27:34]...)\n\tb = append(b, \" y\")\n\tb = append(b, a[35:]...)\n\ts := NewMatcher(a, b)\n\tw := &bytes.Buffer{}\n\tfor _, g := range s.GetGroupedOpCodes(-1) {\n\t\tfmt.Fprintf(w, \"group\\n\")\n\t\tfor _, op := range g {\n\t\t\tfmt.Fprintf(w, \" %s, %d, %d, %d, %d\\n\", string(op.Tag),\n\t\t\t\top.I1, op.I2, op.J1, op.J2)\n\t\t}\n\t}\n\tresult := string(w.Bytes())\n\texpected := `group\n e, 5, 8, 5, 8\n i, 8, 8, 8, 9\n e, 8, 11, 9, 12\ngroup\n e, 16, 19, 17, 20\n r, 19, 20, 20, 21\n e, 20, 22, 21, 23\n d, 22, 27, 23, 23\n e, 27, 30, 23, 26\ngroup\n e, 31, 34, 27, 30\n r, 34, 35, 30, 31\n e, 35, 38, 31, 34\n`\n\tif expected != result {\n\t\tt.Errorf(\"unexpected op codes: \\n%s\", result)\n\t}\n}\n\nfunc ExampleGetUnifiedDiffString() {\n\ta := `one\ntwo\nthree\nfour\nfmt.Printf(\"%s,%T\",a,b)`\n\tb := `zero\none\nthree\nfour`\n\tdiff := UnifiedDiff{\n\t\tA: SplitLines(a),\n\t\tB: SplitLines(b),\n\t\tFromFile: \"Original\",\n\t\tFromDate: \"2005-01-26 23:30:50\",\n\t\tToFile: \"Current\",\n\t\tToDate: \"2010-04-02 10:20:52\",\n\t\tContext: 3,\n\t}\n\tresult, _ := GetUnifiedDiffString(diff)\n\tfmt.Println(strings.Replace(result, \"\\t\", \" \", -1))\n\t// Output:\n\t// --- Original 2005-01-26 23:30:50\n\t// +++ Current 2010-04-02 10:20:52\n\t// @@ -1,5 +1,4 @@\n\t// +zero\n\t// one\n\t// -two\n\t// three\n\t// four\n\t// -fmt.Printf(\"%s,%T\",a,b)\n}\n\nfunc ExampleGetContextDiffString() {\n\ta := `one\ntwo\nthree\nfour\nfmt.Printf(\"%s,%T\",a,b)`\n\tb := `zero\none\ntree\nfour`\n\tdiff := ContextDiff{\n\t\tA: SplitLines(a),\n\t\tB: SplitLines(b),\n\t\tFromFile: \"Original\",\n\t\tToFile: \"Current\",\n\t\tContext: 3,\n\t\tEol: \"\\n\",\n\t}\n\tresult, _ := GetContextDiffString(diff)\n\tfmt.Print(strings.Replace(result, \"\\t\", \" \", -1))\n\t// Output:\n\t// *** Original\n\t// --- Current\n\t// ***************\n\t// *** 1,5 ****\n\t// one\n\t// ! two\n\t// ! three\n\t// four\n\t// - fmt.Printf(\"%s,%T\",a,b)\n\t// --- 1,4 ----\n\t// + zero\n\t// one\n\t// ! tree\n\t// four\n}\n\nfunc ExampleGetContextDiffString_second() {\n\ta := `one\ntwo\nthree\nfour`\n\tb := `zero\none\ntree\nfour`\n\tdiff := ContextDiff{\n\t\tA: SplitLines(a),\n\t\tB: SplitLines(b),\n\t\tFromFile: \"Original\",\n\t\tToFile: \"Current\",\n\t\tContext: 3,\n\t\tEol: \"\\n\",\n\t}\n\tresult, _ := GetContextDiffString(diff)\n\tfmt.Printf(strings.Replace(result, \"\\t\", \" \", -1))\n\t// Output:\n\t// *** Original\n\t// --- Current\n\t// ***************\n\t// *** 1,4 ****\n\t// one\n\t// ! two\n\t// ! three\n\t// four\n\t// --- 1,4 ----\n\t// + zero\n\t// one\n\t// ! tree\n\t// four\n}\n\nfunc rep(s string, count int) string {\n\treturn strings.Repeat(s, count)\n}\n\nfunc TestWithAsciiOneInsert(t *testing.T) {\n\tsm := NewMatcher(splitChars(rep(\"b\", 100)),\n\t\tsplitChars(\"a\"+rep(\"b\", 100)))\n\tassertAlmostEqual(t, sm.Ratio(), 0.995, 3)\n\tassertEqual(t, sm.GetOpCodes(),\n\t\t[]OpCode{{'i', 0, 0, 0, 1}, {'e', 0, 100, 1, 101}})\n\tassertEqual(t, len(sm.bPopular), 0)\n\n\tsm = NewMatcher(splitChars(rep(\"b\", 100)),\n\t\tsplitChars(rep(\"b\", 50)+\"a\"+rep(\"b\", 50)))\n\tassertAlmostEqual(t, sm.Ratio(), 0.995, 3)\n\tassertEqual(t, sm.GetOpCodes(),\n\t\t[]OpCode{{'e', 0, 50, 0, 50}, {'i', 50, 50, 50, 51}, {'e', 50, 100, 51, 101}})\n\tassertEqual(t, len(sm.bPopular), 0)\n}\n\nfunc TestWithAsciiOnDelete(t *testing.T) {\n\tsm := NewMatcher(splitChars(rep(\"a\", 40)+\"c\"+rep(\"b\", 40)),\n\t\tsplitChars(rep(\"a\", 40)+rep(\"b\", 40)))\n\tassertAlmostEqual(t, sm.Ratio(), 0.994, 3)\n\tassertEqual(t, sm.GetOpCodes(),\n\t\t[]OpCode{{'e', 0, 40, 0, 40}, {'d', 40, 41, 40, 40}, {'e', 41, 81, 40, 80}})\n}\n\nfunc TestWithAsciiBJunk(t *testing.T) {\n\tisJunk := func(s string) bool {\n\t\treturn s == \" \"\n\t}\n\tsm := NewMatcherWithJunk(splitChars(rep(\"a\", 40)+rep(\"b\", 40)),\n\t\tsplitChars(rep(\"a\", 44)+rep(\"b\", 40)), true, isJunk)\n\tassertEqual(t, sm.bJunk, map[string]struct{}{})\n\n\tsm = NewMatcherWithJunk(splitChars(rep(\"a\", 40)+rep(\"b\", 40)),\n\t\tsplitChars(rep(\"a\", 44)+rep(\"b\", 40)+rep(\" \", 20)), false, isJunk)\n\tassertEqual(t, sm.bJunk, map[string]struct{}{\" \": struct{}{}})\n\n\tisJunk = func(s string) bool {\n\t\treturn s == \" \" || s == \"b\"\n\t}\n\tsm = NewMatcherWithJunk(splitChars(rep(\"a\", 40)+rep(\"b\", 40)),\n\t\tsplitChars(rep(\"a\", 44)+rep(\"b\", 40)+rep(\" \", 20)), false, isJunk)\n\tassertEqual(t, sm.bJunk, map[string]struct{}{\" \": struct{}{}, \"b\": struct{}{}})\n}\n\nfunc TestSFBugsRatioForNullSeqn(t *testing.T) {\n\tsm := NewMatcher(nil, nil)\n\tassertEqual(t, sm.Ratio(), 1.0)\n\tassertEqual(t, sm.QuickRatio(), 1.0)\n\tassertEqual(t, sm.RealQuickRatio(), 1.0)\n}\n\nfunc TestSFBugsComparingEmptyLists(t *testing.T) {\n\tgroups := NewMatcher(nil, nil).GetGroupedOpCodes(-1)\n\tassertEqual(t, len(groups), 0)\n\tdiff := UnifiedDiff{\n\t\tFromFile: \"Original\",\n\t\tToFile: \"Current\",\n\t\tContext: 3,\n\t}\n\tresult, err := GetUnifiedDiffString(diff)\n\tassertEqual(t, err, nil)\n\tassertEqual(t, result, \"\")\n}\n\nfunc TestOutputFormatRangeFormatUnified(t *testing.T) {\n\t// Per the diff spec at http://www.unix.org/single_unix_specification/\n\t//\n\t// Each field shall be of the form:\n\t// %1d\", if the range contains exactly one line,\n\t// and:\n\t// \"%1d,%1d\", , otherwise.\n\t// If a range is empty, its beginning line number shall be the number of\n\t// the line just before the range, or 0 if the empty range starts the file.\n\tfm := formatRangeUnified\n\tassertEqual(t, fm(3, 3), \"3,0\")\n\tassertEqual(t, fm(3, 4), \"4\")\n\tassertEqual(t, fm(3, 5), \"4,2\")\n\tassertEqual(t, fm(3, 6), \"4,3\")\n\tassertEqual(t, fm(0, 0), \"0,0\")\n}\n\nfunc TestOutputFormatRangeFormatContext(t *testing.T) {\n\t// Per the diff spec at http://www.unix.org/single_unix_specification/\n\t//\n\t// The range of lines in file1 shall be written in the following format\n\t// if the range contains two or more lines:\n\t// \"*** %d,%d ****\\n\", , \n\t// and the following format otherwise:\n\t// \"*** %d ****\\n\", \n\t// The ending line number of an empty range shall be the number of the preceding line,\n\t// or 0 if the range is at the start of the file.\n\t//\n\t// Next, the range of lines in file2 shall be written in the following format\n\t// if the range contains two or more lines:\n\t// \"--- %d,%d ----\\n\", , \n\t// and the following format otherwise:\n\t// \"--- %d ----\\n\", \n\tfm := formatRangeContext\n\tassertEqual(t, fm(3, 3), \"3\")\n\tassertEqual(t, fm(3, 4), \"4\")\n\tassertEqual(t, fm(3, 5), \"4,5\")\n\tassertEqual(t, fm(3, 6), \"4,6\")\n\tassertEqual(t, fm(0, 0), \"0\")\n}\n\nfunc TestOutputFormatTabDelimiter(t *testing.T) {\n\tdiff := UnifiedDiff{\n\t\tA: splitChars(\"one\"),\n\t\tB: splitChars(\"two\"),\n\t\tFromFile: \"Original\",\n\t\tFromDate: \"2005-01-26 23:30:50\",\n\t\tToFile: \"Current\",\n\t\tToDate: \"2010-04-12 10:20:52\",\n\t\tEol: \"\\n\",\n\t}\n\tud, err := GetUnifiedDiffString(diff)\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(ud)[:2], []string{\n\t\t\"--- Original\\t2005-01-26 23:30:50\\n\",\n\t\t\"+++ Current\\t2010-04-12 10:20:52\\n\",\n\t})\n\tcd, err := GetContextDiffString(ContextDiff(diff))\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(cd)[:2], []string{\n\t\t\"*** Original\\t2005-01-26 23:30:50\\n\",\n\t\t\"--- Current\\t2010-04-12 10:20:52\\n\",\n\t})\n}\n\nfunc TestOutputFormatNoTrailingTabOnEmptyFiledate(t *testing.T) {\n\tdiff := UnifiedDiff{\n\t\tA: splitChars(\"one\"),\n\t\tB: splitChars(\"two\"),\n\t\tFromFile: \"Original\",\n\t\tToFile: \"Current\",\n\t\tEol: \"\\n\",\n\t}\n\tud, err := GetUnifiedDiffString(diff)\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(ud)[:2], []string{\"--- Original\\n\", \"+++ Current\\n\"})\n\n\tcd, err := GetContextDiffString(ContextDiff(diff))\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(cd)[:2], []string{\"*** Original\\n\", \"--- Current\\n\"})\n}\n\nfunc TestOmitFilenames(t *testing.T) {\n\tdiff := UnifiedDiff{\n\t\tA: SplitLines(\"o\\nn\\ne\\n\"),\n\t\tB: SplitLines(\"t\\nw\\no\\n\"),\n\t\tEol: \"\\n\",\n\t}\n\tud, err := GetUnifiedDiffString(diff)\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(ud), []string{\n\t\t\"@@ -0,0 +1,2 @@\\n\",\n\t\t\"+t\\n\",\n\t\t\"+w\\n\",\n\t\t\"@@ -2,2 +3,0 @@\\n\",\n\t\t\"-n\\n\",\n\t\t\"-e\\n\",\n\t\t\"\\n\",\n\t})\n\n\tcd, err := GetContextDiffString(ContextDiff(diff))\n\tassertEqual(t, err, nil)\n\tassertEqual(t, SplitLines(cd), []string{\n\t\t\"***************\\n\",\n\t\t\"*** 0 ****\\n\",\n\t\t\"--- 1,2 ----\\n\",\n\t\t\"+ t\\n\",\n\t\t\"+ w\\n\",\n\t\t\"***************\\n\",\n\t\t\"*** 2,3 ****\\n\",\n\t\t\"- n\\n\",\n\t\t\"- e\\n\",\n\t\t\"--- 3 ----\\n\",\n\t\t\"\\n\",\n\t})\n}\n\nfunc TestSplitLines(t *testing.T) {\n\tallTests := []struct {\n\t\tinput string\n\t\twant []string\n\t}{\n\t\t{\"foo\", []string{\"foo\\n\"}},\n\t\t{\"foo\\nbar\", []string{\"foo\\n\", \"bar\\n\"}},\n\t\t{\"foo\\nbar\\n\", []string{\"foo\\n\", \"bar\\n\", \"\\n\"}},\n\t}\n\tfor _, test := range allTests {\n\t\tassertEqual(t, SplitLines(test.input), test.want)\n\t}\n}\n\nfunc benchmarkSplitLines(b *testing.B, count int) {\n\tstr := strings.Repeat(\"foo\\n\", count)\n\n\tb.ResetTimer()\n\n\tn := 0\n\tfor i := 0; i < b.N; i++ {\n\t\tn += len(SplitLines(str))\n\t}\n}\n\nfunc BenchmarkSplitLines100(b *testing.B) {\n\tbenchmarkSplitLines(b, 100)\n}\n\nfunc BenchmarkSplitLines10000(b *testing.B) {\n\tbenchmarkSplitLines(b, 10000)\n}\n"
},
{
"path": "internal/ring/ring.go",
"content": "package ring\n\n// Ring is a very simple ring buffer implementation that uses a slice. The\n// internal slice will only grow, never shrink. When it grows, it grows in\n// chunks of \"chunkSize\" (given as argument in the [New] function). Pointer and\n// reference types can be safely used because memory is cleared.\ntype Ring[T any] struct {\n\tdata []T\n\tback, len, chunkSize int\n}\n\nfunc New[T any](chunkSize int) *Ring[T] {\n\tif chunkSize < 1 {\n\t\tpanic(\"chunkSize must be greater than zero\")\n\t}\n\treturn &Ring[T]{\n\t\tchunkSize: chunkSize,\n\t}\n}\n\nfunc (r *Ring[T]) Len() int {\n\treturn r.len\n}\n\nfunc (r *Ring[T]) Cap() int {\n\treturn len(r.data)\n}\n\nfunc (r *Ring[T]) Reset() {\n\tvar zero T\n\tfor i := range r.data {\n\t\tr.data[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the \"clear\" builtin can be used\n\t}\n\tr.back = 0\n\tr.len = 0\n}\n\n// Nth returns the n-th oldest value (zero-based) in the ring without making\n// any change.\nfunc (r *Ring[T]) Nth(n int) (v T, ok bool) {\n\tif n < 0 || n >= r.len || len(r.data) == 0 {\n\t\treturn v, false\n\t}\n\tn = (n + r.back) % len(r.data)\n\treturn r.data[n], true\n}\n\n// Dequeue returns the oldest value.\nfunc (r *Ring[T]) Dequeue() (v T, ok bool) {\n\tif r.len == 0 {\n\t\treturn v, false\n\t}\n\tv, r.data[r.back] = r.data[r.back], v // retrieve and clear mem\n\tr.len--\n\tr.back = (r.back + 1) % len(r.data)\n\treturn v, true\n}\n\n// Enqueue adds an item to the ring.\nfunc (r *Ring[T]) Enqueue(v T) {\n\tif r.len == len(r.data) {\n\t\tr.grow()\n\t}\n\twritePos := (r.back + r.len) % len(r.data)\n\tr.data[writePos] = v\n\tr.len++\n}\n\nfunc (r *Ring[T]) grow() {\n\ts := make([]T, len(r.data)+r.chunkSize)\n\tif r.len > 0 {\n\t\tchunk1 := r.back + r.len\n\t\tif chunk1 > len(r.data) {\n\t\t\tchunk1 = len(r.data)\n\t\t}\n\t\tcopied := copy(s, r.data[r.back:chunk1])\n\n\t\tif copied < r.len { // wrapped slice\n\t\t\tchunk2 := r.len - copied\n\t\t\tcopy(s[copied:], r.data[:chunk2])\n\t\t}\n\t}\n\tr.back = 0\n\tr.data = s\n}\n"
},
{
"path": "internal/ring/ring_test.go",
"content": "package ring\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n)\n\nfunc TestRing(t *testing.T) {\n\ttype op = ringOp[int]\n\ttestRing(t, New[int](3),\n\t\t// noops on empty ring\n\t\top{cap: 0, opType: opRst, value: 0, items: []int{}},\n\t\top{cap: 0, opType: opDeq, value: 0, items: []int{}},\n\n\t\t// basic\n\t\top{cap: 3, opType: opEnq, value: 1, items: []int{1}},\n\t\top{cap: 3, opType: opDeq, value: 1, items: []int{}},\n\n\t\t// wrapping\n\t\top{cap: 3, opType: opEnq, value: 2, items: []int{2}},\n\t\top{cap: 3, opType: opEnq, value: 3, items: []int{2, 3}},\n\t\top{cap: 3, opType: opEnq, value: 4, items: []int{2, 3, 4}},\n\t\top{cap: 3, opType: opDeq, value: 2, items: []int{3, 4}},\n\t\top{cap: 3, opType: opDeq, value: 3, items: []int{4}},\n\t\top{cap: 3, opType: opDeq, value: 4, items: []int{}},\n\n\t\t// resetting\n\t\top{cap: 3, opType: opEnq, value: 2, items: []int{2}},\n\t\top{cap: 3, opType: opRst, value: 0, items: []int{}},\n\t\top{cap: 3, opType: opDeq, value: 0, items: []int{}},\n\n\t\t// growing without wrapping\n\t\top{cap: 3, opType: opEnq, value: 5, items: []int{5}},\n\t\top{cap: 3, opType: opEnq, value: 6, items: []int{5, 6}},\n\t\top{cap: 3, opType: opEnq, value: 7, items: []int{5, 6, 7}},\n\t\top{cap: 6, opType: opEnq, value: 8, items: []int{5, 6, 7, 8}},\n\t\top{cap: 6, opType: opRst, value: 0, items: []int{}},\n\t\top{cap: 6, opType: opDeq, value: 0, items: []int{}},\n\n\t\t// growing and wrapping\n\t\top{cap: 6, opType: opEnq, value: 9, items: []int{9}},\n\t\top{cap: 6, opType: opEnq, value: 10, items: []int{9, 10}},\n\t\top{cap: 6, opType: opEnq, value: 11, items: []int{9, 10, 11}},\n\t\top{cap: 6, opType: opEnq, value: 12, items: []int{9, 10, 11, 12}},\n\t\top{cap: 6, opType: opEnq, value: 13, items: []int{9, 10, 11, 12, 13}},\n\t\top{cap: 6, opType: opEnq, value: 14, items: []int{9, 10, 11, 12, 13, 14}},\n\t\top{cap: 6, opType: opDeq, value: 9, items: []int{10, 11, 12, 13, 14}},\n\t\top{cap: 6, opType: opDeq, value: 10, items: []int{11, 12, 13, 14}},\n\t\top{cap: 6, opType: opEnq, value: 15, items: []int{11, 12, 13, 14, 15}},\n\t\top{cap: 6, opType: opEnq, value: 16, items: []int{11, 12, 13, 14, 15, 16}},\n\t\top{cap: 9, opType: opEnq, value: 17, items: []int{11, 12, 13, 14, 15, 16, 17}}, // grows wrapped\n\t\top{cap: 9, opType: opDeq, value: 11, items: []int{12, 13, 14, 15, 16, 17}},\n\t\top{cap: 9, opType: opDeq, value: 12, items: []int{13, 14, 15, 16, 17}},\n\t\top{cap: 9, opType: opDeq, value: 13, items: []int{14, 15, 16, 17}},\n\t\top{cap: 9, opType: opDeq, value: 14, items: []int{15, 16, 17}},\n\t\top{cap: 9, opType: opDeq, value: 15, items: []int{16, 17}},\n\t\top{cap: 9, opType: opDeq, value: 16, items: []int{17}},\n\t\top{cap: 9, opType: opDeq, value: 17, items: []int{}},\n\t\top{cap: 9, opType: opDeq, value: 0, items: []int{}},\n\t)\n\n\tt.Run(\"should panic on invalid chunkSize\", func(t *testing.T) {\n\t\tdefer func() {\n\t\t\tif r := recover(); r == nil {\n\t\t\t\tt.Fatalf(\"should have panicked\")\n\t\t\t}\n\t\t}()\n\t\tNew[int](0)\n\t})\n}\n\nconst (\n\topEnq = iota // enqueue an item\n\topDeq // dequeue an item and an item was available\n\topRst // reset\n)\n\ntype ringOp[T comparable] struct {\n\tcap int // expected values\n\topType int // opEnq or opDeq\n\tvalue T // value to enqueue or value expected for dequeue; ignored for opRst\n\titems []T // items left\n}\n\nfunc testRing[T comparable](t *testing.T, r *Ring[T], ops ...ringOp[T]) {\n\tfor i, op := range ops {\n\t\ttestOK := t.Run(fmt.Sprintf(\"opIndex=%v\", i), func(t *testing.T) {\n\t\t\ttestRingOp(t, r, op)\n\t\t})\n\t\tif !testOK {\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc testRingOp[T comparable](t *testing.T, r *Ring[T], op ringOp[T]) {\n\tvar zero T\n\tswitch op.opType {\n\tcase opEnq:\n\t\tr.Enqueue(op.value)\n\tcase opDeq:\n\t\tshouldSucceed := r.Len() > 0\n\t\tv, ok := r.Dequeue()\n\t\tswitch {\n\t\tcase ok != shouldSucceed:\n\t\t\tt.Fatalf(\"should have succeeded: %v\", shouldSucceed)\n\t\tcase ok && v != op.value:\n\t\t\tt.Fatalf(\"expected value: %v; got: %v\", op.value, v)\n\t\tcase !ok && v != zero:\n\t\t\tt.Fatalf(\"expected zero value; got: %v\", v)\n\t\t}\n\tcase opRst:\n\t\tr.Reset()\n\t}\n\tif c := r.Cap(); c != op.cap {\n\t\tt.Fatalf(\"expected cap: %v; got: %v\", op.cap, c)\n\t}\n\tif l := r.Len(); l != len(op.items) {\n\t\tt.Errorf(\"expected Len(): %v; got: %v\", len(op.items), l)\n\t}\n\tvar got []T\n\tfor i := 0; ; i++ {\n\t\tv, ok := r.Nth(i)\n\t\tif !ok {\n\t\t\tbreak\n\t\t}\n\t\tgot = append(got, v)\n\t}\n\tif l := len(got); l != len(op.items) {\n\t\tt.Errorf(\"expected items: %v\\ngot items: %v\", op.items, got)\n\t}\n\tfor i := range op.items {\n\t\tif op.items[i] != got[i] {\n\t\t\tt.Fatalf(\"expected items: %v\\ngot items: %v\", op.items, got)\n\t\t}\n\t}\n\tif v, ok := r.Nth(len(op.items)); ok || v != zero {\n\t\tt.Fatalf(\"expected no more items, got: v=%v; ok=%v\", v, ok)\n\t}\n}\n"
},
{
"path": "internal/spew/bypass.go",
"content": "// Copyright (c) 2015-2016 Dave Collins \n//\n// Permission to use, copy, modify, and distribute this software for any\n// purpose with or without fee is hereby granted, provided that the above\n// copyright notice and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n// NOTE: Due to the following build constraints, this file will only be compiled\n// when the code is not running on Google App Engine, compiled by GopherJS, and\n// \"-tags safe\" is not added to the go build command line. The \"disableunsafe\"\n// tag is deprecated and thus should not be used.\n// Go versions prior to 1.4 are disabled because they use a different layout\n// for interfaces which make the implementation of unsafeReflectValue more complex.\n//go:build !js && !appengine && !safe && !disableunsafe && go1.4\n// +build !js,!appengine,!safe,!disableunsafe,go1.4\n\npackage spew\n\nimport (\n\t\"reflect\"\n\t\"unsafe\"\n)\n\nconst (\n\t// UnsafeDisabled is a build-time constant which specifies whether or\n\t// not access to the unsafe package is available.\n\tUnsafeDisabled = false\n\n\t// ptrSize is the size of a pointer on the current arch.\n\tptrSize = unsafe.Sizeof((*byte)(nil))\n)\n\ntype flag uintptr\n\nvar (\n\t// flagRO indicates whether the value field of a reflect.Value\n\t// is read-only.\n\tflagRO flag\n\n\t// flagAddr indicates whether the address of the reflect.Value's\n\t// value may be taken.\n\tflagAddr flag\n)\n\n// flagKindMask holds the bits that make up the kind\n// part of the flags field. In all the supported versions,\n// it is in the lower 5 bits.\nconst flagKindMask = flag(0x1f)\n\n// Different versions of Go have used different\n// bit layouts for the flags type. This table\n// records the known combinations.\nvar okFlags = []struct {\n\tro, addr flag\n}{{\n\t// From Go 1.4 to 1.5\n\tro: 1 << 5,\n\taddr: 1 << 7,\n}, {\n\t// Up to Go tip.\n\tro: 1<<5 | 1<<6,\n\taddr: 1 << 8,\n}}\n\nvar flagValOffset = func() uintptr {\n\tfield, ok := reflect.TypeOf(reflect.Value{}).FieldByName(\"flag\")\n\tif !ok {\n\t\tpanic(\"reflect.Value has no flag field\")\n\t}\n\treturn field.Offset\n}()\n\n// flagField returns a pointer to the flag field of a reflect.Value.\nfunc flagField(v *reflect.Value) *flag {\n\treturn (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))\n}\n\n// unsafeReflectValue converts the passed reflect.Value into a one that bypasses\n// the typical safety restrictions preventing access to unaddressable and\n// unexported data. It works by digging the raw pointer to the underlying\n// value out of the protected value and generating a new unprotected (unsafe)\n// reflect.Value to it.\n//\n// This allows us to check for implementations of the Stringer and error\n// interfaces to be used for pretty printing ordinarily unaddressable and\n// inaccessible values such as unexported struct fields.\nfunc unsafeReflectValue(v reflect.Value) reflect.Value {\n\tif !v.IsValid() || (v.CanInterface() && v.CanAddr()) {\n\t\treturn v\n\t}\n\tflagFieldPtr := flagField(&v)\n\t*flagFieldPtr &^= flagRO\n\t*flagFieldPtr |= flagAddr\n\treturn v\n}\n\n// Sanity checks against future reflect package changes\n// to the type or semantics of the Value.flag field.\nfunc init() {\n\tfield, ok := reflect.TypeOf(reflect.Value{}).FieldByName(\"flag\")\n\tif !ok {\n\t\tpanic(\"reflect.Value has no flag field\")\n\t}\n\tif field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {\n\t\tpanic(\"reflect.Value flag field has changed kind\")\n\t}\n\ttype t0 int\n\tvar t struct {\n\t\tA t0\n\t\t// t0 will have flagEmbedRO set.\n\t\tt0\n\t\t// a will have flagStickyRO set\n\t\ta t0\n\t}\n\tvA := reflect.ValueOf(t).FieldByName(\"A\")\n\tva := reflect.ValueOf(t).FieldByName(\"a\")\n\tvt0 := reflect.ValueOf(t).FieldByName(\"t0\")\n\n\t// Infer flagRO from the difference between the flags\n\t// for the (otherwise identical) fields in t.\n\tflagPublic := *flagField(&vA)\n\tflagWithRO := *flagField(&va) | *flagField(&vt0)\n\tflagRO = flagPublic ^ flagWithRO\n\n\t// Infer flagAddr from the difference between a value\n\t// taken from a pointer and not.\n\tvPtrA := reflect.ValueOf(&t).Elem().FieldByName(\"A\")\n\tflagNoPtr := *flagField(&vA)\n\tflagPtr := *flagField(&vPtrA)\n\tflagAddr = flagNoPtr ^ flagPtr\n\n\t// Check that the inferred flags tally with one of the known versions.\n\tfor _, f := range okFlags {\n\t\tif flagRO == f.ro && flagAddr == f.addr {\n\t\t\treturn\n\t\t}\n\t}\n\tpanic(\"reflect.Value read-only flag has changed semantics\")\n}\n"
},
{
"path": "internal/spew/bypasssafe.go",
"content": "// Copyright (c) 2015-2016 Dave Collins \n//\n// Permission to use, copy, modify, and distribute this software for any\n// purpose with or without fee is hereby granted, provided that the above\n// copyright notice and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n// NOTE: Due to the following build constraints, this file will only be compiled\n// when the code is running on Google App Engine, compiled by GopherJS, or\n// \"-tags safe\" is added to the go build command line. The \"disableunsafe\"\n// tag is deprecated and thus should not be used.\n//go:build js || appengine || safe || disableunsafe || !go1.4\n// +build js appengine safe disableunsafe !go1.4\n\npackage spew\n\nimport \"reflect\"\n\nconst (\n\t// UnsafeDisabled is a build-time constant which specifies whether or\n\t// not access to the unsafe package is available.\n\tUnsafeDisabled = true\n)\n\n// unsafeReflectValue typically converts the passed reflect.Value into a one\n// that bypasses the typical safety restrictions preventing access to\n// unaddressable and unexported data. However, doing this relies on access to\n// the unsafe package. This is a stub version which simply returns the passed\n// reflect.Value when the unsafe package is not available.\nfunc unsafeReflectValue(v reflect.Value) reflect.Value {\n\treturn v\n}\n"
},
{
"path": "internal/spew/common.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strconv\"\n)\n\n// Some constants in the form of bytes to avoid string overhead. This mirrors\n// the technique used in the fmt package.\nvar (\n\tpanicBytes = []byte(\"(PANIC=\")\n\tplusBytes = []byte(\"+\")\n\tiBytes = []byte(\"i\")\n\ttrueBytes = []byte(\"true\")\n\tfalseBytes = []byte(\"false\")\n\tinterfaceBytes = []byte(\"(interface {})\")\n\tcommaNewlineBytes = []byte(\",\\n\")\n\tnewlineBytes = []byte(\"\\n\")\n\topenBraceBytes = []byte(\"{\")\n\topenBraceNewlineBytes = []byte(\"{\\n\")\n\tcloseBraceBytes = []byte(\"}\")\n\tasteriskBytes = []byte(\"*\")\n\tcolonBytes = []byte(\":\")\n\tcolonSpaceBytes = []byte(\": \")\n\topenParenBytes = []byte(\"(\")\n\tcloseParenBytes = []byte(\")\")\n\tspaceBytes = []byte(\" \")\n\tpointerChainBytes = []byte(\"->\")\n\tnilAngleBytes = []byte(\"\")\n\tmaxNewlineBytes = []byte(\"\\n\")\n\tmaxShortBytes = []byte(\"\")\n\tcircularBytes = []byte(\"\")\n\tcircularShortBytes = []byte(\"\")\n\tinvalidAngleBytes = []byte(\"\")\n\topenBracketBytes = []byte(\"[\")\n\tcloseBracketBytes = []byte(\"]\")\n\tpercentBytes = []byte(\"%\")\n\tprecisionBytes = []byte(\".\")\n\topenAngleBytes = []byte(\"<\")\n\tcloseAngleBytes = []byte(\">\")\n\topenMapBytes = []byte(\"map[\")\n\tcloseMapBytes = []byte(\"]\")\n\tlenEqualsBytes = []byte(\"len=\")\n\tcapEqualsBytes = []byte(\"cap=\")\n)\n\n// hexDigits is used to map a decimal value to a hex digit.\nvar hexDigits = \"0123456789abcdef\"\n\n// catchPanic handles any panics that might occur during the handleMethods\n// calls.\nfunc catchPanic(w io.Writer, v reflect.Value) {\n\tif err := recover(); err != nil {\n\t\tw.Write(panicBytes)\n\t\tfmt.Fprintf(w, \"%v\", err)\n\t\tw.Write(closeParenBytes)\n\t}\n}\n\n// handleMethods attempts to call the Error and String methods on the underlying\n// type the passed reflect.Value represents and outputs the result to Writer w.\n//\n// It handles panics in any called methods by catching and displaying the error\n// as the formatted value.\nfunc handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {\n\t// We need an interface to check if the type implements the error or\n\t// Stringer interface. However, the reflect package won't give us an\n\t// interface on certain things like unexported struct fields in order\n\t// to enforce visibility rules. We use unsafe, when it's available,\n\t// to bypass these restrictions since this package does not mutate the\n\t// values.\n\tif !v.CanInterface() {\n\t\tif UnsafeDisabled {\n\t\t\treturn false\n\t\t}\n\n\t\tv = unsafeReflectValue(v)\n\t}\n\n\t// Choose whether or not to do error and Stringer interface lookups against\n\t// the base type or a pointer to the base type depending on settings.\n\t// Technically calling one of these methods with a pointer receiver can\n\t// mutate the value, however, types which choose to satisfy an error or\n\t// Stringer interface with a pointer receiver should not be mutating their\n\t// state inside these interface methods.\n\tif !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {\n\t\tv = unsafeReflectValue(v)\n\t}\n\tif v.CanAddr() {\n\t\tv = v.Addr()\n\t}\n\n\t// Is it an error or Stringer?\n\tswitch iface := v.Interface().(type) {\n\tcase error:\n\t\tdefer catchPanic(w, v)\n\t\tif cs.ContinueOnMethod {\n\t\t\tw.Write(openParenBytes)\n\t\t\tw.Write([]byte(iface.Error()))\n\t\t\tw.Write(closeParenBytes)\n\t\t\tw.Write(spaceBytes)\n\t\t\treturn false\n\t\t}\n\n\t\tw.Write([]byte(iface.Error()))\n\t\treturn true\n\n\tcase fmt.Stringer:\n\t\tdefer catchPanic(w, v)\n\t\tif cs.ContinueOnMethod {\n\t\t\tw.Write(openParenBytes)\n\t\t\tw.Write([]byte(iface.String()))\n\t\t\tw.Write(closeParenBytes)\n\t\t\tw.Write(spaceBytes)\n\t\t\treturn false\n\t\t}\n\t\tw.Write([]byte(iface.String()))\n\t\treturn true\n\t}\n\treturn false\n}\n\n// printBool outputs a boolean value as true or false to Writer w.\nfunc printBool(w io.Writer, val bool) {\n\tif val {\n\t\tw.Write(trueBytes)\n\t} else {\n\t\tw.Write(falseBytes)\n\t}\n}\n\n// printInt outputs a signed integer value to Writer w.\nfunc printInt(w io.Writer, val int64, base int) {\n\tw.Write([]byte(strconv.FormatInt(val, base)))\n}\n\n// printUint outputs an unsigned integer value to Writer w.\nfunc printUint(w io.Writer, val uint64, base int) {\n\tw.Write([]byte(strconv.FormatUint(val, base)))\n}\n\n// printFloat outputs a floating point value using the specified precision,\n// which is expected to be 32 or 64bit, to Writer w.\nfunc printFloat(w io.Writer, val float64, precision int) {\n\tw.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))\n}\n\n// printComplex outputs a complex value using the specified float precision\n// for the real and imaginary parts to Writer w.\nfunc printComplex(w io.Writer, c complex128, floatPrecision int) {\n\tr := real(c)\n\tw.Write(openParenBytes)\n\tw.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))\n\ti := imag(c)\n\tif i >= 0 {\n\t\tw.Write(plusBytes)\n\t}\n\tw.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))\n\tw.Write(iBytes)\n\tw.Write(closeParenBytes)\n}\n\n// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'\n// prefix to Writer w.\nfunc printHexPtr(w io.Writer, p uintptr) {\n\t// Null pointer.\n\tnum := uint64(p)\n\tif num == 0 {\n\t\tw.Write(nilAngleBytes)\n\t\treturn\n\t}\n\n\t// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix\n\tbuf := make([]byte, 18)\n\n\t// It's simpler to construct the hex string right to left.\n\tbase := uint64(16)\n\ti := len(buf) - 1\n\tfor num >= base {\n\t\tbuf[i] = hexDigits[num%base]\n\t\tnum /= base\n\t\ti--\n\t}\n\tbuf[i] = hexDigits[num]\n\n\t// Add '0x' prefix.\n\ti--\n\tbuf[i] = 'x'\n\ti--\n\tbuf[i] = '0'\n\n\t// Strip unused leading bytes.\n\tbuf = buf[i:]\n\tw.Write(buf)\n}\n\n// valuesSorter implements sort.Interface to allow a slice of reflect.Value\n// elements to be sorted.\ntype valuesSorter struct {\n\tvalues []reflect.Value\n\tstrings []string // either nil or same len and values\n\tcs *ConfigState\n}\n\n// newValuesSorter initializes a valuesSorter instance, which holds a set of\n// surrogate keys on which the data should be sorted. It uses flags in\n// ConfigState to decide if and how to populate those surrogate keys.\nfunc newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {\n\tvs := &valuesSorter{values: values, cs: cs}\n\tif canSortSimply(vs.values[0].Kind()) {\n\t\treturn vs\n\t}\n\tif !cs.DisableMethods {\n\t\tvs.strings = make([]string, len(values))\n\t\tfor i := range vs.values {\n\t\t\tb := bytes.Buffer{}\n\t\t\tif !handleMethods(cs, &b, vs.values[i]) {\n\t\t\t\tvs.strings = nil\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tvs.strings[i] = b.String()\n\t\t}\n\t}\n\tif vs.strings == nil && cs.SpewKeys {\n\t\tvs.strings = make([]string, len(values))\n\t\tfor i := range vs.values {\n\t\t\tvs.strings[i] = Sprintf(\"%#v\", vs.values[i].Interface())\n\t\t}\n\t}\n\treturn vs\n}\n\n// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted\n// directly, or whether it should be considered for sorting by surrogate keys\n// (if the ConfigState allows it).\nfunc canSortSimply(kind reflect.Kind) bool {\n\t// This switch parallels valueSortLess, except for the default case.\n\tswitch kind {\n\tcase reflect.Bool:\n\t\treturn true\n\tcase reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:\n\t\treturn true\n\tcase reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:\n\t\treturn true\n\tcase reflect.Float32, reflect.Float64:\n\t\treturn true\n\tcase reflect.String:\n\t\treturn true\n\tcase reflect.Uintptr:\n\t\treturn true\n\tcase reflect.Array:\n\t\treturn true\n\t}\n\treturn false\n}\n\n// Len returns the number of values in the slice. It is part of the\n// sort.Interface implementation.\nfunc (s *valuesSorter) Len() int {\n\treturn len(s.values)\n}\n\n// Swap swaps the values at the passed indices. It is part of the\n// sort.Interface implementation.\nfunc (s *valuesSorter) Swap(i, j int) {\n\ts.values[i], s.values[j] = s.values[j], s.values[i]\n\tif s.strings != nil {\n\t\ts.strings[i], s.strings[j] = s.strings[j], s.strings[i]\n\t}\n}\n\n// valueSortLess returns whether the first value should sort before the second\n// value. It is used by valueSorter.Less as part of the sort.Interface\n// implementation.\nfunc valueSortLess(a, b reflect.Value) bool {\n\tswitch a.Kind() {\n\tcase reflect.Bool:\n\t\treturn !a.Bool() && b.Bool()\n\tcase reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:\n\t\treturn a.Int() < b.Int()\n\tcase reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:\n\t\treturn a.Uint() < b.Uint()\n\tcase reflect.Float32, reflect.Float64:\n\t\treturn a.Float() < b.Float()\n\tcase reflect.String:\n\t\treturn a.String() < b.String()\n\tcase reflect.Uintptr:\n\t\treturn a.Uint() < b.Uint()\n\tcase reflect.Array:\n\t\t// Compare the contents of both arrays.\n\t\tl := a.Len()\n\t\tfor i := 0; i < l; i++ {\n\t\t\tav := a.Index(i)\n\t\t\tbv := b.Index(i)\n\t\t\tif av.Interface() == bv.Interface() {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\treturn valueSortLess(av, bv)\n\t\t}\n\t}\n\treturn a.String() < b.String()\n}\n\n// Less returns whether the value at index i should sort before the\n// value at index j. It is part of the sort.Interface implementation.\nfunc (s *valuesSorter) Less(i, j int) bool {\n\tif s.strings == nil {\n\t\treturn valueSortLess(s.values[i], s.values[j])\n\t}\n\treturn s.strings[i] < s.strings[j]\n}\n\n// sortValues is a sort function that handles both native types and any type that\n// can be converted to error or Stringer. Other inputs are sorted according to\n// their Value.String() value to ensure display stability.\nfunc sortValues(values []reflect.Value, cs *ConfigState) {\n\tif len(values) == 0 {\n\t\treturn\n\t}\n\tsort.Sort(newValuesSorter(values, cs))\n}\n"
},
{
"path": "internal/spew/common_test.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew_test\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"testing\"\n\n\t\"github.com/expr-lang/expr/internal/spew\"\n)\n\n// custom type to test Stinger interface on non-pointer receiver.\ntype stringer string\n\n// String implements the Stringer interface for testing invocation of custom\n// stringers on types with non-pointer receivers.\nfunc (s stringer) String() string {\n\treturn \"stringer \" + string(s)\n}\n\n// custom type to test Stinger interface on pointer receiver.\ntype pstringer string\n\n// String implements the Stringer interface for testing invocation of custom\n// stringers on types with only pointer receivers.\nfunc (s *pstringer) String() string {\n\treturn \"stringer \" + string(*s)\n}\n\n// xref1 and xref2 are cross referencing structs for testing circular reference\n// detection.\ntype xref1 struct {\n\tps2 *xref2\n}\ntype xref2 struct {\n\tps1 *xref1\n}\n\n// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular\n// reference for testing detection.\ntype indirCir1 struct {\n\tps2 *indirCir2\n}\ntype indirCir2 struct {\n\tps3 *indirCir3\n}\ntype indirCir3 struct {\n\tps1 *indirCir1\n}\n\n// embed is used to test embedded structures.\ntype embed struct {\n\ta string\n}\n\n// embedwrap is used to test embedded structures.\ntype embedwrap struct {\n\t*embed\n\te *embed\n}\n\n// panicer is used to intentionally cause a panic for testing spew properly\n// handles them\ntype panicer int\n\nfunc (p panicer) String() string {\n\tpanic(\"test panic\")\n}\n\n// customError is used to test custom error interface invocation.\ntype customError int\n\nfunc (e customError) Error() string {\n\treturn fmt.Sprintf(\"error: %d\", int(e))\n}\n\n// stringizeWants converts a slice of wanted test output into a format suitable\n// for a test error message.\nfunc stringizeWants(wants []string) string {\n\ts := \"\"\n\tfor i, want := range wants {\n\t\tif i > 0 {\n\t\t\ts += fmt.Sprintf(\"want%d: %s\", i+1, want)\n\t\t} else {\n\t\t\ts += \"want: \" + want\n\t\t}\n\t}\n\treturn s\n}\n\n// testFailed returns whether or not a test failed by checking if the result\n// of the test is in the slice of wanted strings.\nfunc testFailed(result string, wants []string) bool {\n\tfor _, want := range wants {\n\t\tif result == want {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\ntype sortableStruct struct {\n\tx int\n}\n\nfunc (ss sortableStruct) String() string {\n\treturn fmt.Sprintf(\"ss.%d\", ss.x)\n}\n\ntype unsortableStruct struct {\n\tx int\n}\n\ntype sortTestCase struct {\n\tinput []reflect.Value\n\texpected []reflect.Value\n}\n\nfunc helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {\n\tgetInterfaces := func(values []reflect.Value) []interface{} {\n\t\tinterfaces := []interface{}{}\n\t\tfor _, v := range values {\n\t\t\tinterfaces = append(interfaces, v.Interface())\n\t\t}\n\t\treturn interfaces\n\t}\n\n\tfor _, test := range tests {\n\t\tspew.SortValues(test.input, cs)\n\t\t// reflect.DeepEqual cannot really make sense of reflect.Value,\n\t\t// probably because of all the pointer tricks. For instance,\n\t\t// v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}\n\t\t// instead.\n\t\tinput := getInterfaces(test.input)\n\t\texpected := getInterfaces(test.expected)\n\t\tif !reflect.DeepEqual(input, expected) {\n\t\t\tt.Errorf(\"Sort mismatch:\\n %v != %v\", input, expected)\n\t\t}\n\t}\n}\n\n// TestSortValues ensures the sort functionality for reflect.Value based sorting\n// works as intended.\nfunc TestSortValues(t *testing.T) {\n\tv := reflect.ValueOf\n\n\ta := v(\"a\")\n\tb := v(\"b\")\n\tc := v(\"c\")\n\tembedA := v(embed{\"a\"})\n\tembedB := v(embed{\"b\"})\n\tembedC := v(embed{\"c\"})\n\ttests := []sortTestCase{\n\t\t// No values.\n\t\t{\n\t\t\t[]reflect.Value{},\n\t\t\t[]reflect.Value{},\n\t\t},\n\t\t// Bools.\n\t\t{\n\t\t\t[]reflect.Value{v(false), v(true), v(false)},\n\t\t\t[]reflect.Value{v(false), v(false), v(true)},\n\t\t},\n\t\t// Ints.\n\t\t{\n\t\t\t[]reflect.Value{v(2), v(1), v(3)},\n\t\t\t[]reflect.Value{v(1), v(2), v(3)},\n\t\t},\n\t\t// Uints.\n\t\t{\n\t\t\t[]reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},\n\t\t\t[]reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},\n\t\t},\n\t\t// Floats.\n\t\t{\n\t\t\t[]reflect.Value{v(2.0), v(1.0), v(3.0)},\n\t\t\t[]reflect.Value{v(1.0), v(2.0), v(3.0)},\n\t\t},\n\t\t// Strings.\n\t\t{\n\t\t\t[]reflect.Value{b, a, c},\n\t\t\t[]reflect.Value{a, b, c},\n\t\t},\n\t\t// Array\n\t\t{\n\t\t\t[]reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},\n\t\t\t[]reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},\n\t\t},\n\t\t// Uintptrs.\n\t\t{\n\t\t\t[]reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},\n\t\t\t[]reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},\n\t\t},\n\t\t// SortableStructs.\n\t\t{\n\t\t\t// Note: not sorted - DisableMethods is set.\n\t\t\t[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},\n\t\t\t[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},\n\t\t},\n\t\t// UnsortableStructs.\n\t\t{\n\t\t\t// Note: not sorted - SpewKeys is false.\n\t\t\t[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},\n\t\t\t[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},\n\t\t},\n\t\t// Invalid.\n\t\t{\n\t\t\t[]reflect.Value{embedB, embedA, embedC},\n\t\t\t[]reflect.Value{embedB, embedA, embedC},\n\t\t},\n\t}\n\tcs := spew.ConfigState{DisableMethods: true, SpewKeys: false}\n\thelpTestSortValues(tests, &cs, t)\n}\n\n// TestSortValuesWithMethods ensures the sort functionality for reflect.Value\n// based sorting works as intended when using string methods.\nfunc TestSortValuesWithMethods(t *testing.T) {\n\tv := reflect.ValueOf\n\n\ta := v(\"a\")\n\tb := v(\"b\")\n\tc := v(\"c\")\n\ttests := []sortTestCase{\n\t\t// Ints.\n\t\t{\n\t\t\t[]reflect.Value{v(2), v(1), v(3)},\n\t\t\t[]reflect.Value{v(1), v(2), v(3)},\n\t\t},\n\t\t// Strings.\n\t\t{\n\t\t\t[]reflect.Value{b, a, c},\n\t\t\t[]reflect.Value{a, b, c},\n\t\t},\n\t\t// SortableStructs.\n\t\t{\n\t\t\t[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},\n\t\t\t[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},\n\t\t},\n\t\t// UnsortableStructs.\n\t\t{\n\t\t\t// Note: not sorted - SpewKeys is false.\n\t\t\t[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},\n\t\t\t[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},\n\t\t},\n\t}\n\tcs := spew.ConfigState{DisableMethods: false, SpewKeys: false}\n\thelpTestSortValues(tests, &cs, t)\n}\n\n// TestSortValuesWithSpew ensures the sort functionality for reflect.Value\n// based sorting works as intended when using spew to stringify keys.\nfunc TestSortValuesWithSpew(t *testing.T) {\n\tv := reflect.ValueOf\n\n\ta := v(\"a\")\n\tb := v(\"b\")\n\tc := v(\"c\")\n\ttests := []sortTestCase{\n\t\t// Ints.\n\t\t{\n\t\t\t[]reflect.Value{v(2), v(1), v(3)},\n\t\t\t[]reflect.Value{v(1), v(2), v(3)},\n\t\t},\n\t\t// Strings.\n\t\t{\n\t\t\t[]reflect.Value{b, a, c},\n\t\t\t[]reflect.Value{a, b, c},\n\t\t},\n\t\t// SortableStructs.\n\t\t{\n\t\t\t[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},\n\t\t\t[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},\n\t\t},\n\t\t// UnsortableStructs.\n\t\t{\n\t\t\t[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},\n\t\t\t[]reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},\n\t\t},\n\t}\n\tcs := spew.ConfigState{DisableMethods: true, SpewKeys: true}\n\thelpTestSortValues(tests, &cs, t)\n}\n"
},
{
"path": "internal/spew/config.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n)\n\n// ConfigState houses the configuration options used by spew to format and\n// display values. There is a global instance, Config, that is used to control\n// all top-level Formatter and Dump functionality. Each ConfigState instance\n// provides methods equivalent to the top-level functions.\n//\n// The zero value for ConfigState provides no indentation. You would typically\n// want to set it to a space or a tab.\n//\n// Alternatively, you can use NewDefaultConfig to get a ConfigState instance\n// with default settings. See the documentation of NewDefaultConfig for default\n// values.\ntype ConfigState struct {\n\t// Indent specifies the string to use for each indentation level. The\n\t// global config instance that all top-level functions use set this to a\n\t// single space by default. If you would like more indentation, you might\n\t// set this to a tab with \"\\t\" or perhaps two spaces with \" \".\n\tIndent string\n\n\t// MaxDepth controls the maximum number of levels to descend into nested\n\t// data structures. The default, 0, means there is no limit.\n\t//\n\t// NOTE: Circular data structures are properly detected, so it is not\n\t// necessary to set this value unless you specifically want to limit deeply\n\t// nested data structures.\n\tMaxDepth int\n\n\t// DisableMethods specifies whether or not error and Stringer interfaces are\n\t// invoked for types that implement them.\n\tDisableMethods bool\n\n\t// DisablePointerMethods specifies whether or not to check for and invoke\n\t// error and Stringer interfaces on types which only accept a pointer\n\t// receiver when the current type is not a pointer.\n\t//\n\t// NOTE: This might be an unsafe action since calling one of these methods\n\t// with a pointer receiver could technically mutate the value, however,\n\t// in practice, types which choose to satisfy an error or Stringer\n\t// interface with a pointer receiver should not be mutating their state\n\t// inside these interface methods. As a result, this option relies on\n\t// access to the unsafe package, so it will not have any effect when\n\t// running in environments without access to the unsafe package such as\n\t// Google App Engine or with the \"safe\" build tag specified.\n\tDisablePointerMethods bool\n\n\t// DisablePointerAddresses specifies whether to disable the printing of\n\t// pointer addresses. This is useful when diffing data structures in tests.\n\tDisablePointerAddresses bool\n\n\t// DisableCapacities specifies whether to disable the printing of capacities\n\t// for arrays, slices, maps and channels. This is useful when diffing\n\t// data structures in tests.\n\tDisableCapacities bool\n\n\t// ContinueOnMethod specifies whether or not recursion should continue once\n\t// a custom error or Stringer interface is invoked. The default, false,\n\t// means it will print the results of invoking the custom error or Stringer\n\t// interface and return immediately instead of continuing to recurse into\n\t// the internals of the data type.\n\t//\n\t// NOTE: This flag does not have any effect if method invocation is disabled\n\t// via the DisableMethods or DisablePointerMethods options.\n\tContinueOnMethod bool\n\n\t// SortKeys specifies map keys should be sorted before being printed. Use\n\t// this to have a more deterministic, diffable output. Note that only\n\t// native types (bool, int, uint, floats, uintptr and string) and types\n\t// that support the error or Stringer interfaces (if methods are\n\t// enabled) are supported, with other types sorted according to the\n\t// reflect.Value.String() output which guarantees display stability.\n\tSortKeys bool\n\n\t// SpewKeys specifies that, as a last resort attempt, map keys should\n\t// be spewed to strings and sorted by those strings. This is only\n\t// considered if SortKeys is true.\n\tSpewKeys bool\n}\n\n// Config is the active configuration of the top-level functions.\n// The configuration can be changed by modifying the contents of spew.Config.\nvar Config = ConfigState{Indent: \" \"}\n\n// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the formatted string as a value that satisfies error. See NewFormatter\n// for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {\n\treturn fmt.Errorf(format, c.convertArgs(a)...)\n}\n\n// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the number of bytes written and any write error encountered. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {\n\treturn fmt.Fprint(w, c.convertArgs(a)...)\n}\n\n// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the number of bytes written and any write error encountered. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {\n\treturn fmt.Fprintf(w, format, c.convertArgs(a)...)\n}\n\n// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it\n// passed with a Formatter interface returned by c.NewFormatter. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {\n\treturn fmt.Fprintln(w, c.convertArgs(a)...)\n}\n\n// Print is a wrapper for fmt.Print that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the number of bytes written and any write error encountered. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Print(c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Print(a ...interface{}) (n int, err error) {\n\treturn fmt.Print(c.convertArgs(a)...)\n}\n\n// Printf is a wrapper for fmt.Printf that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the number of bytes written and any write error encountered. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {\n\treturn fmt.Printf(format, c.convertArgs(a)...)\n}\n\n// Println is a wrapper for fmt.Println that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the number of bytes written and any write error encountered. See\n// NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Println(c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Println(a ...interface{}) (n int, err error) {\n\treturn fmt.Println(c.convertArgs(a)...)\n}\n\n// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the resulting string. See NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Sprint(a ...interface{}) string {\n\treturn fmt.Sprint(c.convertArgs(a)...)\n}\n\n// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were\n// passed with a Formatter interface returned by c.NewFormatter. It returns\n// the resulting string. See NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Sprintf(format string, a ...interface{}) string {\n\treturn fmt.Sprintf(format, c.convertArgs(a)...)\n}\n\n// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it\n// were passed with a Formatter interface returned by c.NewFormatter. It\n// returns the resulting string. See NewFormatter for formatting details.\n//\n// This function is shorthand for the following syntax:\n//\n//\tfmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))\nfunc (c *ConfigState) Sprintln(a ...interface{}) string {\n\treturn fmt.Sprintln(c.convertArgs(a)...)\n}\n\n/*\nNewFormatter returns a custom formatter that satisfies the fmt.Formatter\ninterface. As a result, it integrates cleanly with standard fmt package\nprinting functions. The formatter is useful for inline printing of smaller data\ntypes similar to the standard %v format specifier.\n\nThe custom formatter only responds to the %v (most compact), %+v (adds pointer\naddresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb\ncombinations. Any other verbs such as %x and %q will be sent to the\nstandard fmt package for formatting. In addition, the custom formatter ignores\nthe width and precision arguments (however they will still work on the format\nspecifiers not handled by the custom formatter).\n\nTypically this function shouldn't be called directly. It is much easier to make\nuse of the custom formatter by calling one of the convenience functions such as\nc.Printf, c.Println, or c.Printf.\n*/\nfunc (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {\n\treturn newFormatter(c, v)\n}\n\n// Fdump formats and displays the passed arguments to io.Writer w. It formats\n// exactly the same as Dump.\nfunc (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {\n\tfdump(c, w, a...)\n}\n\n/*\nDump displays the passed parameters to standard out with newlines, customizable\nindentation, and additional debug information such as complete types and all\npointer addresses used to indirect to the final value. It provides the\nfollowing features over the built-in printing facilities provided by the fmt\npackage:\n\n - Pointers are dereferenced and followed\n - Circular data structures are detected and handled properly\n - Custom Stringer/error interfaces are optionally invoked, including\n on unexported types\n - Custom types which only implement the Stringer/error interfaces via\n a pointer receiver are optionally invoked when passing non-pointer\n variables\n - Byte arrays and slices are dumped like the hexdump -C command which\n includes offsets, byte values in hex, and ASCII output\n\nThe configuration options are controlled by modifying the public members\nof c. See ConfigState for options documentation.\n\nSee Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to\nget the formatted result as a string.\n*/\nfunc (c *ConfigState) Dump(a ...interface{}) {\n\tfdump(c, os.Stdout, a...)\n}\n\n// Sdump returns a string with the passed arguments formatted exactly the same\n// as Dump.\nfunc (c *ConfigState) Sdump(a ...interface{}) string {\n\tvar buf bytes.Buffer\n\tfdump(c, &buf, a...)\n\treturn buf.String()\n}\n\n// convertArgs accepts a slice of arguments and returns a slice of the same\n// length with each argument converted to a spew Formatter interface using\n// the ConfigState associated with s.\nfunc (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {\n\tformatters = make([]interface{}, len(args))\n\tfor index, arg := range args {\n\t\tformatters[index] = newFormatter(c, arg)\n\t}\n\treturn formatters\n}\n\n// NewDefaultConfig returns a ConfigState with the following default settings.\n//\n//\tIndent: \" \"\n//\tMaxDepth: 0\n//\tDisableMethods: false\n//\tDisablePointerMethods: false\n//\tContinueOnMethod: false\n//\tSortKeys: false\nfunc NewDefaultConfig() *ConfigState {\n\treturn &ConfigState{Indent: \" \"}\n}\n"
},
{
"path": "internal/spew/doc.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\n/*\nPackage spew implements a deep pretty printer for Go data structures to aid in\ndebugging.\n\nA quick overview of the additional features spew provides over the built-in\nprinting facilities for Go data types are as follows:\n\n - Pointers are dereferenced and followed\n - Circular data structures are detected and handled properly\n - Custom Stringer/error interfaces are optionally invoked, including\n on unexported types\n - Custom types which only implement the Stringer/error interfaces via\n a pointer receiver are optionally invoked when passing non-pointer\n variables\n - Byte arrays and slices are dumped like the hexdump -C command which\n includes offsets, byte values in hex, and ASCII output (only when using\n Dump style)\n\nThere are two different approaches spew allows for dumping Go data structures:\n\n - Dump style which prints with newlines, customizable indentation,\n and additional debug information such as types and all pointer addresses\n used to indirect to the final value\n - A custom Formatter interface that integrates cleanly with the standard fmt\n package and replaces %v, %+v, %#v, and %#+v to provide inline printing\n similar to the default %v while providing the additional functionality\n outlined above and passing unsupported format verbs such as %x and %q\n along to fmt\n\n# Quick Start\n\nThis section demonstrates how to quickly get started with spew. See the\nsections below for further details on formatting and configuration options.\n\nTo dump a variable with full newlines, indentation, type, and pointer\ninformation use Dump, Fdump, or Sdump:\n\n\tspew.Dump(myVar1, myVar2, ...)\n\tspew.Fdump(someWriter, myVar1, myVar2, ...)\n\tstr := spew.Sdump(myVar1, myVar2, ...)\n\nAlternatively, if you would prefer to use format strings with a compacted inline\nprinting style, use the convenience wrappers Printf, Fprintf, etc with\n%v (most compact), %+v (adds pointer addresses), %#v (adds types), or\n%#+v (adds types and pointer addresses):\n\n\tspew.Printf(\"myVar1: %v -- myVar2: %+v\", myVar1, myVar2)\n\tspew.Printf(\"myVar3: %#v -- myVar4: %#+v\", myVar3, myVar4)\n\tspew.Fprintf(someWriter, \"myVar1: %v -- myVar2: %+v\", myVar1, myVar2)\n\tspew.Fprintf(someWriter, \"myVar3: %#v -- myVar4: %#+v\", myVar3, myVar4)\n\n# Configuration Options\n\nConfiguration of spew is handled by fields in the ConfigState type. For\nconvenience, all of the top-level functions use a global state available\nvia the spew.Config global.\n\nIt is also possible to create a ConfigState instance that provides methods\nequivalent to the top-level functions. This allows concurrent configuration\noptions. See the ConfigState documentation for more details.\n\nThe following configuration options are available:\n\n - Indent\n String to use for each indentation level for Dump functions.\n It is a single space by default. A popular alternative is \"\\t\".\n\n - MaxDepth\n Maximum number of levels to descend into nested data structures.\n There is no limit by default.\n\n - DisableMethods\n Disables invocation of error and Stringer interface methods.\n Method invocation is enabled by default.\n\n - DisablePointerMethods\n Disables invocation of error and Stringer interface methods on types\n which only accept pointer receivers from non-pointer variables.\n Pointer method invocation is enabled by default.\n\n - DisablePointerAddresses\n DisablePointerAddresses specifies whether to disable the printing of\n pointer addresses. This is useful when diffing data structures in tests.\n\n - DisableCapacities\n DisableCapacities specifies whether to disable the printing of\n capacities for arrays, slices, maps and channels. This is useful when\n diffing data structures in tests.\n\n - ContinueOnMethod\n Enables recursion into types after invoking error and Stringer interface\n methods. Recursion after method invocation is disabled by default.\n\n - SortKeys\n Specifies map keys should be sorted before being printed. Use\n this to have a more deterministic, diffable output. Note that\n only native types (bool, int, uint, floats, uintptr and string)\n and types which implement error or Stringer interfaces are\n supported with other types sorted according to the\n reflect.Value.String() output which guarantees display\n stability. Natural map order is used by default.\n\n - SpewKeys\n Specifies that, as a last resort attempt, map keys should be\n spewed to strings and sorted by those strings. This is only\n considered if SortKeys is true.\n\n# Dump Usage\n\nSimply call spew.Dump with a list of variables you want to dump:\n\n\tspew.Dump(myVar1, myVar2, ...)\n\nYou may also call spew.Fdump if you would prefer to output to an arbitrary\nio.Writer. For example, to dump to standard error:\n\n\tspew.Fdump(os.Stderr, myVar1, myVar2, ...)\n\nA third option is to call spew.Sdump to get the formatted output as a string:\n\n\tstr := spew.Sdump(myVar1, myVar2, ...)\n\n# Sample Dump Output\n\nSee the Dump example for details on the setup of the types and variables being\nshown here.\n\n\t(main.Foo) {\n\t unexportedField: (*main.Bar)(0xf84002e210)({\n\t flag: (main.Flag) flagTwo,\n\t data: (uintptr) \n\t }),\n\t ExportedField: (map[interface {}]interface {}) (len=1) {\n\t (string) (len=3) \"one\": (bool) true\n\t }\n\t}\n\nByte (and uint8) arrays and slices are displayed uniquely like the hexdump -C\ncommand as shown.\n\n\t([]uint8) (len=32 cap=32) {\n\t 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |\n\t 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!\"#$%&'()*+,-./0|\n\t 00000020 31 32 |12|\n\t}\n\n# Custom Formatter\n\nSpew provides a custom formatter that implements the fmt.Formatter interface\nso that it integrates cleanly with standard fmt package printing functions. The\nformatter is useful for inline printing of smaller data types similar to the\nstandard %v format specifier.\n\nThe custom formatter only responds to the %v (most compact), %+v (adds pointer\naddresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb\ncombinations. Any other verbs such as %x and %q will be sent to the\nstandard fmt package for formatting. In addition, the custom formatter ignores\nthe width and precision arguments (however they will still work on the format\nspecifiers not handled by the custom formatter).\n\n# Custom Formatter Usage\n\nThe simplest way to make use of the spew custom formatter is to call one of the\nconvenience functions such as spew.Printf, spew.Println, or spew.Printf. The\nfunctions have syntax you are most likely already familiar with:\n\n\tspew.Printf(\"myVar1: %v -- myVar2: %+v\", myVar1, myVar2)\n\tspew.Printf(\"myVar3: %#v -- myVar4: %#+v\", myVar3, myVar4)\n\tspew.Println(myVar, myVar2)\n\tspew.Fprintf(os.Stderr, \"myVar1: %v -- myVar2: %+v\", myVar1, myVar2)\n\tspew.Fprintf(os.Stderr, \"myVar3: %#v -- myVar4: %#+v\", myVar3, myVar4)\n\nSee the Index for the full list convenience functions.\n\n# Sample Formatter Output\n\nDouble pointer to a uint8:\n\n\t %v: <**>5\n\t %+v: <**>(0xf8400420d0->0xf8400420c8)5\n\t %#v: (**uint8)5\n\t%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5\n\nPointer to circular struct with a uint8 field and a pointer to itself:\n\n\t %v: <*>{1 <*>}\n\t %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)}\n\t %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)}\n\t%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)}\n\nSee the Printf example for details on the setup of variables being shown\nhere.\n\n# Errors\n\nSince it is possible for custom Stringer/error interfaces to panic, spew\ndetects them and handles them internally by printing the panic information\ninline with the output. Since spew is intended to provide deep pretty printing\ncapabilities on structures, it intentionally does not return any errors.\n*/\npackage spew\n"
},
{
"path": "internal/spew/dump.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew\n\nimport (\n\t\"bytes\"\n\t\"encoding/hex\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n)\n\nvar (\n\t// uint8Type is a reflect.Type representing a uint8. It is used to\n\t// convert cgo types to uint8 slices for hexdumping.\n\tuint8Type = reflect.TypeOf(uint8(0))\n\n\t// cCharRE is a regular expression that matches a cgo char.\n\t// It is used to detect character arrays to hexdump them.\n\tcCharRE = regexp.MustCompile(`^.*\\._Ctype_char$`)\n\n\t// cUnsignedCharRE is a regular expression that matches a cgo unsigned\n\t// char. It is used to detect unsigned character arrays to hexdump\n\t// them.\n\tcUnsignedCharRE = regexp.MustCompile(`^.*\\._Ctype_unsignedchar$`)\n\n\t// cUint8tCharRE is a regular expression that matches a cgo uint8_t.\n\t// It is used to detect uint8_t arrays to hexdump them.\n\tcUint8tCharRE = regexp.MustCompile(`^.*\\._Ctype_uint8_t$`)\n)\n\n// dumpState contains information about the state of a dump operation.\ntype dumpState struct {\n\tw io.Writer\n\tdepth int\n\tpointers map[uintptr]int\n\tignoreNextType bool\n\tignoreNextIndent bool\n\tcs *ConfigState\n}\n\n// indent performs indentation according to the depth level and cs.Indent\n// option.\nfunc (d *dumpState) indent() {\n\tif d.ignoreNextIndent {\n\t\td.ignoreNextIndent = false\n\t\treturn\n\t}\n\td.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))\n}\n\n// unpackValue returns values inside of non-nil interfaces when possible.\n// This is useful for data types like structs, arrays, slices, and maps which\n// can contain varying types packed inside an interface.\nfunc (d *dumpState) unpackValue(v reflect.Value) reflect.Value {\n\tif v.Kind() == reflect.Interface && !v.IsNil() {\n\t\tv = v.Elem()\n\t}\n\treturn v\n}\n\n// dumpPtr handles formatting of pointers by indirecting them as necessary.\nfunc (d *dumpState) dumpPtr(v reflect.Value) {\n\t// Remove pointers at or below the current depth from map used to detect\n\t// circular refs.\n\tfor k, depth := range d.pointers {\n\t\tif depth >= d.depth {\n\t\t\tdelete(d.pointers, k)\n\t\t}\n\t}\n\n\t// Keep list of all dereferenced pointers to show later.\n\tpointerChain := make([]uintptr, 0)\n\n\t// Figure out how many levels of indirection there are by dereferencing\n\t// pointers and unpacking interfaces down the chain while detecting circular\n\t// references.\n\tnilFound := false\n\tcycleFound := false\n\tindirects := 0\n\tve := v\n\tfor ve.Kind() == reflect.Ptr {\n\t\tif ve.IsNil() {\n\t\t\tnilFound = true\n\t\t\tbreak\n\t\t}\n\t\tindirects++\n\t\taddr := ve.Pointer()\n\t\tpointerChain = append(pointerChain, addr)\n\t\tif pd, ok := d.pointers[addr]; ok && pd < d.depth {\n\t\t\tcycleFound = true\n\t\t\tindirects--\n\t\t\tbreak\n\t\t}\n\t\td.pointers[addr] = d.depth\n\n\t\tve = ve.Elem()\n\t\tif ve.Kind() == reflect.Interface {\n\t\t\tif ve.IsNil() {\n\t\t\t\tnilFound = true\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tve = ve.Elem()\n\t\t}\n\t}\n\n\t// Display type information.\n\td.w.Write(openParenBytes)\n\td.w.Write(bytes.Repeat(asteriskBytes, indirects))\n\td.w.Write([]byte(ve.Type().String()))\n\td.w.Write(closeParenBytes)\n\n\t// Display pointer information.\n\tif !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {\n\t\td.w.Write(openParenBytes)\n\t\tfor i, addr := range pointerChain {\n\t\t\tif i > 0 {\n\t\t\t\td.w.Write(pointerChainBytes)\n\t\t\t}\n\t\t\tprintHexPtr(d.w, addr)\n\t\t}\n\t\td.w.Write(closeParenBytes)\n\t}\n\n\t// Display dereferenced value.\n\td.w.Write(openParenBytes)\n\tswitch {\n\tcase nilFound:\n\t\td.w.Write(nilAngleBytes)\n\n\tcase cycleFound:\n\t\td.w.Write(circularBytes)\n\n\tdefault:\n\t\td.ignoreNextType = true\n\t\td.dump(ve)\n\t}\n\td.w.Write(closeParenBytes)\n}\n\n// dumpSlice handles formatting of arrays and slices. Byte (uint8 under\n// reflection) arrays and slices are dumped in hexdump -C fashion.\nfunc (d *dumpState) dumpSlice(v reflect.Value) {\n\t// Determine whether this type should be hex dumped or not. Also,\n\t// for types which should be hexdumped, try to use the underlying data\n\t// first, then fall back to trying to convert them to a uint8 slice.\n\tvar buf []uint8\n\tdoConvert := false\n\tdoHexDump := false\n\tnumEntries := v.Len()\n\tif numEntries > 0 {\n\t\tvt := v.Index(0).Type()\n\t\tvts := vt.String()\n\t\tswitch {\n\t\t// C types that need to be converted.\n\t\tcase cCharRE.MatchString(vts):\n\t\t\tfallthrough\n\t\tcase cUnsignedCharRE.MatchString(vts):\n\t\t\tfallthrough\n\t\tcase cUint8tCharRE.MatchString(vts):\n\t\t\tdoConvert = true\n\n\t\t// Try to use existing uint8 slices and fall back to converting\n\t\t// and copying if that fails.\n\t\tcase vt.Kind() == reflect.Uint8:\n\t\t\t// We need an addressable interface to convert the type\n\t\t\t// to a byte slice. However, the reflect package won't\n\t\t\t// give us an interface on certain things like\n\t\t\t// unexported struct fields in order to enforce\n\t\t\t// visibility rules. We use unsafe, when available, to\n\t\t\t// bypass these restrictions since this package does not\n\t\t\t// mutate the values.\n\t\t\tvs := v\n\t\t\tif !vs.CanInterface() || !vs.CanAddr() {\n\t\t\t\tvs = unsafeReflectValue(vs)\n\t\t\t}\n\t\t\tif !UnsafeDisabled {\n\t\t\t\tvs = vs.Slice(0, numEntries)\n\n\t\t\t\t// Use the existing uint8 slice if it can be\n\t\t\t\t// type asserted.\n\t\t\t\tiface := vs.Interface()\n\t\t\t\tif slice, ok := iface.([]uint8); ok {\n\t\t\t\t\tbuf = slice\n\t\t\t\t\tdoHexDump = true\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// The underlying data needs to be converted if it can't\n\t\t\t// be type asserted to a uint8 slice.\n\t\t\tdoConvert = true\n\t\t}\n\n\t\t// Copy and convert the underlying type if needed.\n\t\tif doConvert && vt.ConvertibleTo(uint8Type) {\n\t\t\t// Convert and copy each element into a uint8 byte\n\t\t\t// slice.\n\t\t\tbuf = make([]uint8, numEntries)\n\t\t\tfor i := 0; i < numEntries; i++ {\n\t\t\t\tvv := v.Index(i)\n\t\t\t\tbuf[i] = uint8(vv.Convert(uint8Type).Uint())\n\t\t\t}\n\t\t\tdoHexDump = true\n\t\t}\n\t}\n\n\t// Hexdump the entire slice as needed.\n\tif doHexDump {\n\t\tindent := strings.Repeat(d.cs.Indent, d.depth)\n\t\tstr := indent + hex.Dump(buf)\n\t\tstr = strings.Replace(str, \"\\n\", \"\\n\"+indent, -1)\n\t\tstr = strings.TrimRight(str, d.cs.Indent)\n\t\td.w.Write([]byte(str))\n\t\treturn\n\t}\n\n\t// Recursively call dump for each item.\n\tfor i := 0; i < numEntries; i++ {\n\t\td.dump(d.unpackValue(v.Index(i)))\n\t\tif i < (numEntries - 1) {\n\t\t\td.w.Write(commaNewlineBytes)\n\t\t} else {\n\t\t\td.w.Write(newlineBytes)\n\t\t}\n\t}\n}\n\n// dump is the main workhorse for dumping a value. It uses the passed reflect\n// value to figure out what kind of object we are dealing with and formats it\n// appropriately. It is a recursive function, however circular data structures\n// are detected and handled properly.\nfunc (d *dumpState) dump(v reflect.Value) {\n\t// Handle invalid reflect values immediately.\n\tkind := v.Kind()\n\tif kind == reflect.Invalid {\n\t\td.w.Write(invalidAngleBytes)\n\t\treturn\n\t}\n\n\t// Handle pointers specially.\n\tif kind == reflect.Ptr {\n\t\td.indent()\n\t\td.dumpPtr(v)\n\t\treturn\n\t}\n\n\t// Print type information unless already handled elsewhere.\n\tif !d.ignoreNextType {\n\t\td.indent()\n\t\td.w.Write(openParenBytes)\n\t\td.w.Write([]byte(v.Type().String()))\n\t\td.w.Write(closeParenBytes)\n\t\td.w.Write(spaceBytes)\n\t}\n\td.ignoreNextType = false\n\n\t// Display length and capacity if the built-in len and cap functions\n\t// work with the value's kind and the len/cap itself is non-zero.\n\tvalueLen, valueCap := 0, 0\n\tswitch v.Kind() {\n\tcase reflect.Array, reflect.Slice, reflect.Chan:\n\t\tvalueLen, valueCap = v.Len(), v.Cap()\n\tcase reflect.Map, reflect.String:\n\t\tvalueLen = v.Len()\n\t}\n\tif valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {\n\t\td.w.Write(openParenBytes)\n\t\tif valueLen != 0 {\n\t\t\td.w.Write(lenEqualsBytes)\n\t\t\tprintInt(d.w, int64(valueLen), 10)\n\t\t}\n\t\tif !d.cs.DisableCapacities && valueCap != 0 {\n\t\t\tif valueLen != 0 {\n\t\t\t\td.w.Write(spaceBytes)\n\t\t\t}\n\t\t\td.w.Write(capEqualsBytes)\n\t\t\tprintInt(d.w, int64(valueCap), 10)\n\t\t}\n\t\td.w.Write(closeParenBytes)\n\t\td.w.Write(spaceBytes)\n\t}\n\n\t// Call Stringer/error interfaces if they exist and the handle methods flag\n\t// is enabled\n\tif !d.cs.DisableMethods {\n\t\tif (kind != reflect.Invalid) && (kind != reflect.Interface) {\n\t\t\tif handled := handleMethods(d.cs, d.w, v); handled {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t}\n\n\tswitch kind {\n\tcase reflect.Invalid:\n\t\t// Do nothing. We should never get here since invalid has already\n\t\t// been handled above.\n\n\tcase reflect.Bool:\n\t\tprintBool(d.w, v.Bool())\n\n\tcase reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:\n\t\tprintInt(d.w, v.Int(), 10)\n\n\tcase reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:\n\t\tprintUint(d.w, v.Uint(), 10)\n\n\tcase reflect.Float32:\n\t\tprintFloat(d.w, v.Float(), 32)\n\n\tcase reflect.Float64:\n\t\tprintFloat(d.w, v.Float(), 64)\n\n\tcase reflect.Complex64:\n\t\tprintComplex(d.w, v.Complex(), 32)\n\n\tcase reflect.Complex128:\n\t\tprintComplex(d.w, v.Complex(), 64)\n\n\tcase reflect.Slice:\n\t\tif v.IsNil() {\n\t\t\td.w.Write(nilAngleBytes)\n\t\t\tbreak\n\t\t}\n\t\tfallthrough\n\n\tcase reflect.Array:\n\t\td.w.Write(openBraceNewlineBytes)\n\t\td.depth++\n\t\tif (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {\n\t\t\td.indent()\n\t\t\td.w.Write(maxNewlineBytes)\n\t\t} else {\n\t\t\td.dumpSlice(v)\n\t\t}\n\t\td.depth--\n\t\td.indent()\n\t\td.w.Write(closeBraceBytes)\n\n\tcase reflect.String:\n\t\td.w.Write([]byte(strconv.Quote(v.String())))\n\n\tcase reflect.Interface:\n\t\t// The only time we should get here is for nil interfaces due to\n\t\t// unpackValue calls.\n\t\tif v.IsNil() {\n\t\t\td.w.Write(nilAngleBytes)\n\t\t}\n\n\tcase reflect.Ptr:\n\t\t// Do nothing. We should never get here since pointers have already\n\t\t// been handled above.\n\n\tcase reflect.Map:\n\t\t// nil maps should be indicated as different than empty maps\n\t\tif v.IsNil() {\n\t\t\td.w.Write(nilAngleBytes)\n\t\t\tbreak\n\t\t}\n\n\t\td.w.Write(openBraceNewlineBytes)\n\t\td.depth++\n\t\tif (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {\n\t\t\td.indent()\n\t\t\td.w.Write(maxNewlineBytes)\n\t\t} else {\n\t\t\tnumEntries := v.Len()\n\t\t\tkeys := v.MapKeys()\n\t\t\tif d.cs.SortKeys {\n\t\t\t\tsortValues(keys, d.cs)\n\t\t\t}\n\t\t\tfor i, key := range keys {\n\t\t\t\td.dump(d.unpackValue(key))\n\t\t\t\td.w.Write(colonSpaceBytes)\n\t\t\t\td.ignoreNextIndent = true\n\t\t\t\td.dump(d.unpackValue(v.MapIndex(key)))\n\t\t\t\tif i < (numEntries - 1) {\n\t\t\t\t\td.w.Write(commaNewlineBytes)\n\t\t\t\t} else {\n\t\t\t\t\td.w.Write(newlineBytes)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\td.depth--\n\t\td.indent()\n\t\td.w.Write(closeBraceBytes)\n\n\tcase reflect.Struct:\n\t\td.w.Write(openBraceNewlineBytes)\n\t\td.depth++\n\t\tif (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {\n\t\t\td.indent()\n\t\t\td.w.Write(maxNewlineBytes)\n\t\t} else {\n\t\t\tvt := v.Type()\n\t\t\tnumFields := v.NumField()\n\t\t\tfor i := 0; i < numFields; i++ {\n\t\t\t\td.indent()\n\t\t\t\tvtf := vt.Field(i)\n\t\t\t\td.w.Write([]byte(vtf.Name))\n\t\t\t\td.w.Write(colonSpaceBytes)\n\t\t\t\td.ignoreNextIndent = true\n\t\t\t\td.dump(d.unpackValue(v.Field(i)))\n\t\t\t\tif i < (numFields - 1) {\n\t\t\t\t\td.w.Write(commaNewlineBytes)\n\t\t\t\t} else {\n\t\t\t\t\td.w.Write(newlineBytes)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\td.depth--\n\t\td.indent()\n\t\td.w.Write(closeBraceBytes)\n\n\tcase reflect.Uintptr:\n\t\tprintHexPtr(d.w, uintptr(v.Uint()))\n\n\tcase reflect.UnsafePointer, reflect.Chan, reflect.Func:\n\t\tprintHexPtr(d.w, v.Pointer())\n\n\t// There were not any other types at the time this code was written, but\n\t// fall back to letting the default fmt package handle it in case any new\n\t// types are added.\n\tdefault:\n\t\tif v.CanInterface() {\n\t\t\tfmt.Fprintf(d.w, \"%v\", v.Interface())\n\t\t} else {\n\t\t\tfmt.Fprintf(d.w, \"%v\", v.String())\n\t\t}\n\t}\n}\n\n// fdump is a helper function to consolidate the logic from the various public\n// methods which take varying writers and config states.\nfunc fdump(cs *ConfigState, w io.Writer, a ...interface{}) {\n\tfor _, arg := range a {\n\t\tif arg == nil {\n\t\t\tw.Write(interfaceBytes)\n\t\t\tw.Write(spaceBytes)\n\t\t\tw.Write(nilAngleBytes)\n\t\t\tw.Write(newlineBytes)\n\t\t\tcontinue\n\t\t}\n\n\t\td := dumpState{w: w, cs: cs}\n\t\td.pointers = make(map[uintptr]int)\n\t\td.dump(reflect.ValueOf(arg))\n\t\td.w.Write(newlineBytes)\n\t}\n}\n\n// Fdump formats and displays the passed arguments to io.Writer w. It formats\n// exactly the same as Dump.\nfunc Fdump(w io.Writer, a ...interface{}) {\n\tfdump(&Config, w, a...)\n}\n\n// Sdump returns a string with the passed arguments formatted exactly the same\n// as Dump.\nfunc Sdump(a ...interface{}) string {\n\tvar buf bytes.Buffer\n\tfdump(&Config, &buf, a...)\n\treturn buf.String()\n}\n\n/*\nDump displays the passed parameters to standard out with newlines, customizable\nindentation, and additional debug information such as complete types and all\npointer addresses used to indirect to the final value. It provides the\nfollowing features over the built-in printing facilities provided by the fmt\npackage:\n\n - Pointers are dereferenced and followed\n - Circular data structures are detected and handled properly\n - Custom Stringer/error interfaces are optionally invoked, including\n on unexported types\n - Custom types which only implement the Stringer/error interfaces via\n a pointer receiver are optionally invoked when passing non-pointer\n variables\n - Byte arrays and slices are dumped like the hexdump -C command which\n includes offsets, byte values in hex, and ASCII output\n\nThe configuration options are controlled by an exported package global,\nspew.Config. See ConfigState for options documentation.\n\nSee Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to\nget the formatted result as a string.\n*/\nfunc Dump(a ...interface{}) {\n\tfdump(&Config, os.Stdout, a...)\n}\n"
},
{
"path": "internal/spew/dump_test.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\n/*\nTest Summary:\nNOTE: For each test, a nil pointer, a single pointer and double pointer to the\nbase test element are also tested to ensure proper indirection across all types.\n\n- Max int8, int16, int32, int64, int\n- Max uint8, uint16, uint32, uint64, uint\n- Boolean true and false\n- Standard complex64 and complex128\n- Array containing standard ints\n- Array containing type with custom formatter on pointer receiver only\n- Array containing interfaces\n- Array containing bytes\n- Slice containing standard float32 values\n- Slice containing type with custom formatter on pointer receiver only\n- Slice containing interfaces\n- Slice containing bytes\n- Nil slice\n- Standard string\n- Nil interface\n- Sub-interface\n- Map with string keys and int vals\n- Map with custom formatter type on pointer receiver only keys and vals\n- Map with interface keys and values\n- Map with nil interface value\n- Struct with primitives\n- Struct that contains another struct\n- Struct that contains custom type with Stringer pointer interface via both\n exported and unexported fields\n- Struct that contains embedded struct and field to same struct\n- Uintptr to 0 (null pointer)\n- Uintptr address of real variable\n- Unsafe.Pointer to 0 (null pointer)\n- Unsafe.Pointer to address of real variable\n- Nil channel\n- Standard int channel\n- Function with no params and no returns\n- Function with param and no returns\n- Function with multiple params and multiple returns\n- Struct that is circular through self referencing\n- Structs that are circular through cross referencing\n- Structs that are indirectly circular\n- Type that panics in its Stringer interface\n*/\n\npackage spew_test\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"testing\"\n\t\"unsafe\"\n\n\t\"github.com/expr-lang/expr/internal/spew\"\n)\n\n// dumpTest is used to describe a test to be performed against the Dump method.\ntype dumpTest struct {\n\tin interface{}\n\twants []string\n}\n\n// dumpTests houses all of the tests to be performed against the Dump method.\nvar dumpTests = make([]dumpTest, 0)\n\n// addDumpTest is a helper method to append the passed input and desired result\n// to dumpTests\nfunc addDumpTest(in interface{}, wants ...string) {\n\ttest := dumpTest{in, wants}\n\tdumpTests = append(dumpTests, test)\n}\n\nfunc addIntDumpTests() {\n\t// Max int8.\n\tv := int8(127)\n\tnv := (*int8)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"int8\"\n\tvs := \"127\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Max int16.\n\tv2 := int16(32767)\n\tnv2 := (*int16)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"int16\"\n\tv2s := \"32767\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n\n\t// Max int32.\n\tv3 := int32(2147483647)\n\tnv3 := (*int32)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"int32\"\n\tv3s := \"2147483647\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n\n\t// Max int64.\n\tv4 := int64(9223372036854775807)\n\tnv4 := (*int64)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"int64\"\n\tv4s := \"9223372036854775807\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\taddDumpTest(pv4, \"(*\"+v4t+\")(\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(&pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(nv4, \"(*\"+v4t+\")()\\n\")\n\n\t// Max int.\n\tv5 := int(2147483647)\n\tnv5 := (*int)(nil)\n\tpv5 := &v5\n\tv5Addr := fmt.Sprintf(\"%p\", pv5)\n\tpv5Addr := fmt.Sprintf(\"%p\", &pv5)\n\tv5t := \"int\"\n\tv5s := \"2147483647\"\n\taddDumpTest(v5, \"(\"+v5t+\") \"+v5s+\"\\n\")\n\taddDumpTest(pv5, \"(*\"+v5t+\")(\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(&pv5, \"(**\"+v5t+\")(\"+pv5Addr+\"->\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(nv5, \"(*\"+v5t+\")()\\n\")\n}\n\nfunc addUintDumpTests() {\n\t// Max uint8.\n\tv := uint8(255)\n\tnv := (*uint8)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"uint8\"\n\tvs := \"255\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Max uint16.\n\tv2 := uint16(65535)\n\tnv2 := (*uint16)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uint16\"\n\tv2s := \"65535\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n\n\t// Max uint32.\n\tv3 := uint32(4294967295)\n\tnv3 := (*uint32)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"uint32\"\n\tv3s := \"4294967295\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n\n\t// Max uint64.\n\tv4 := uint64(18446744073709551615)\n\tnv4 := (*uint64)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"uint64\"\n\tv4s := \"18446744073709551615\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\taddDumpTest(pv4, \"(*\"+v4t+\")(\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(&pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(nv4, \"(*\"+v4t+\")()\\n\")\n\n\t// Max uint.\n\tv5 := uint(4294967295)\n\tnv5 := (*uint)(nil)\n\tpv5 := &v5\n\tv5Addr := fmt.Sprintf(\"%p\", pv5)\n\tpv5Addr := fmt.Sprintf(\"%p\", &pv5)\n\tv5t := \"uint\"\n\tv5s := \"4294967295\"\n\taddDumpTest(v5, \"(\"+v5t+\") \"+v5s+\"\\n\")\n\taddDumpTest(pv5, \"(*\"+v5t+\")(\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(&pv5, \"(**\"+v5t+\")(\"+pv5Addr+\"->\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(nv5, \"(*\"+v5t+\")()\\n\")\n}\n\nfunc addBoolDumpTests() {\n\t// Boolean true.\n\tv := bool(true)\n\tnv := (*bool)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"bool\"\n\tvs := \"true\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Boolean false.\n\tv2 := bool(false)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"bool\"\n\tv2s := \"false\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n}\n\nfunc addFloatDumpTests() {\n\t// Standard float32.\n\tv := float32(3.1415)\n\tnv := (*float32)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"float32\"\n\tvs := \"3.1415\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Standard float64.\n\tv2 := float64(3.1415926)\n\tnv2 := (*float64)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"float64\"\n\tv2s := \"3.1415926\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n}\n\nfunc addComplexDumpTests() {\n\t// Standard complex64.\n\tv := complex(float32(6), -2)\n\tnv := (*complex64)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"complex64\"\n\tvs := \"(6-2i)\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Standard complex128.\n\tv2 := complex(float64(-6), 2)\n\tnv2 := (*complex128)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"complex128\"\n\tv2s := \"(-6+2i)\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n}\n\nfunc addArrayDumpTests() {\n\t// Array containing standard ints.\n\tv := [3]int{1, 2, 3}\n\tvLen := fmt.Sprintf(\"%d\", len(v))\n\tvCap := fmt.Sprintf(\"%d\", cap(v))\n\tnv := (*[3]int)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"int\"\n\tvs := \"(len=\" + vLen + \" cap=\" + vCap + \") {\\n (\" + vt + \") 1,\\n (\" +\n\t\tvt + \") 2,\\n (\" + vt + \") 3\\n}\"\n\taddDumpTest(v, \"([3]\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*[3]\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**[3]\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*[3]\"+vt+\")()\\n\")\n\n\t// Array containing type with custom formatter on pointer receiver only.\n\tv2i0 := pstringer(\"1\")\n\tv2i1 := pstringer(\"2\")\n\tv2i2 := pstringer(\"3\")\n\tv2 := [3]pstringer{v2i0, v2i1, v2i2}\n\tv2i0Len := fmt.Sprintf(\"%d\", len(v2i0))\n\tv2i1Len := fmt.Sprintf(\"%d\", len(v2i1))\n\tv2i2Len := fmt.Sprintf(\"%d\", len(v2i2))\n\tv2Len := fmt.Sprintf(\"%d\", len(v2))\n\tv2Cap := fmt.Sprintf(\"%d\", cap(v2))\n\tnv2 := (*[3]pstringer)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"spew_test.pstringer\"\n\tv2sp := \"(len=\" + v2Len + \" cap=\" + v2Cap + \") {\\n (\" + v2t +\n\t\t\") (len=\" + v2i0Len + \") stringer 1,\\n (\" + v2t +\n\t\t\") (len=\" + v2i1Len + \") stringer 2,\\n (\" + v2t +\n\t\t\") (len=\" + v2i2Len + \") \" + \"stringer 3\\n}\"\n\tv2s := v2sp\n\tif spew.UnsafeDisabled {\n\t\tv2s = \"(len=\" + v2Len + \" cap=\" + v2Cap + \") {\\n (\" + v2t +\n\t\t\t\") (len=\" + v2i0Len + \") \\\"1\\\",\\n (\" + v2t + \") (len=\" +\n\t\t\tv2i1Len + \") \\\"2\\\",\\n (\" + v2t + \") (len=\" + v2i2Len +\n\t\t\t\") \" + \"\\\"3\\\"\\n}\"\n\t}\n\taddDumpTest(v2, \"([3]\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*[3]\"+v2t+\")(\"+v2Addr+\")(\"+v2sp+\")\\n\")\n\taddDumpTest(&pv2, \"(**[3]\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2sp+\")\\n\")\n\taddDumpTest(nv2, \"(*[3]\"+v2t+\")()\\n\")\n\n\t// Array containing interfaces.\n\tv3i0 := \"one\"\n\tv3 := [3]interface{}{v3i0, int(2), uint(3)}\n\tv3i0Len := fmt.Sprintf(\"%d\", len(v3i0))\n\tv3Len := fmt.Sprintf(\"%d\", len(v3))\n\tv3Cap := fmt.Sprintf(\"%d\", cap(v3))\n\tnv3 := (*[3]interface{})(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"[3]interface {}\"\n\tv3t2 := \"string\"\n\tv3t3 := \"int\"\n\tv3t4 := \"uint\"\n\tv3s := \"(len=\" + v3Len + \" cap=\" + v3Cap + \") {\\n (\" + v3t2 + \") \" +\n\t\t\"(len=\" + v3i0Len + \") \\\"one\\\",\\n (\" + v3t3 + \") 2,\\n (\" +\n\t\tv3t4 + \") 3\\n}\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n\n\t// Array containing bytes.\n\tv4 := [34]byte{\n\t\t0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,\n\t\t0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,\n\t\t0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,\n\t\t0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,\n\t\t0x31, 0x32,\n\t}\n\tv4Len := fmt.Sprintf(\"%d\", len(v4))\n\tv4Cap := fmt.Sprintf(\"%d\", cap(v4))\n\tnv4 := (*[34]byte)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"[34]uint8\"\n\tv4s := \"(len=\" + v4Len + \" cap=\" + v4Cap + \") \" +\n\t\t\"{\\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20\" +\n\t\t\" |............... |\\n\" +\n\t\t\" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30\" +\n\t\t\" |!\\\"#$%&'()*+,-./0|\\n\" +\n\t\t\" 00000020 31 32 \" +\n\t\t\" |12|\\n}\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\taddDumpTest(pv4, \"(*\"+v4t+\")(\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(&pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(nv4, \"(*\"+v4t+\")()\\n\")\n}\n\nfunc addSliceDumpTests() {\n\t// Slice containing standard float32 values.\n\tv := []float32{3.14, 6.28, 12.56}\n\tvLen := fmt.Sprintf(\"%d\", len(v))\n\tvCap := fmt.Sprintf(\"%d\", cap(v))\n\tnv := (*[]float32)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"float32\"\n\tvs := \"(len=\" + vLen + \" cap=\" + vCap + \") {\\n (\" + vt + \") 3.14,\\n (\" +\n\t\tvt + \") 6.28,\\n (\" + vt + \") 12.56\\n}\"\n\taddDumpTest(v, \"([]\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*[]\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**[]\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*[]\"+vt+\")()\\n\")\n\n\t// Slice containing type with custom formatter on pointer receiver only.\n\tv2i0 := pstringer(\"1\")\n\tv2i1 := pstringer(\"2\")\n\tv2i2 := pstringer(\"3\")\n\tv2 := []pstringer{v2i0, v2i1, v2i2}\n\tv2i0Len := fmt.Sprintf(\"%d\", len(v2i0))\n\tv2i1Len := fmt.Sprintf(\"%d\", len(v2i1))\n\tv2i2Len := fmt.Sprintf(\"%d\", len(v2i2))\n\tv2Len := fmt.Sprintf(\"%d\", len(v2))\n\tv2Cap := fmt.Sprintf(\"%d\", cap(v2))\n\tnv2 := (*[]pstringer)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"spew_test.pstringer\"\n\tv2s := \"(len=\" + v2Len + \" cap=\" + v2Cap + \") {\\n (\" + v2t + \") (len=\" +\n\t\tv2i0Len + \") stringer 1,\\n (\" + v2t + \") (len=\" + v2i1Len +\n\t\t\") stringer 2,\\n (\" + v2t + \") (len=\" + v2i2Len + \") \" +\n\t\t\"stringer 3\\n}\"\n\taddDumpTest(v2, \"([]\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*[]\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**[]\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*[]\"+v2t+\")()\\n\")\n\n\t// Slice containing interfaces.\n\tv3i0 := \"one\"\n\tv3 := []interface{}{v3i0, int(2), uint(3), nil}\n\tv3i0Len := fmt.Sprintf(\"%d\", len(v3i0))\n\tv3Len := fmt.Sprintf(\"%d\", len(v3))\n\tv3Cap := fmt.Sprintf(\"%d\", cap(v3))\n\tnv3 := (*[]interface{})(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"[]interface {}\"\n\tv3t2 := \"string\"\n\tv3t3 := \"int\"\n\tv3t4 := \"uint\"\n\tv3t5 := \"interface {}\"\n\tv3s := \"(len=\" + v3Len + \" cap=\" + v3Cap + \") {\\n (\" + v3t2 + \") \" +\n\t\t\"(len=\" + v3i0Len + \") \\\"one\\\",\\n (\" + v3t3 + \") 2,\\n (\" +\n\t\tv3t4 + \") 3,\\n (\" + v3t5 + \") \\n}\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n\n\t// Slice containing bytes.\n\tv4 := []byte{\n\t\t0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,\n\t\t0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,\n\t\t0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,\n\t\t0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,\n\t\t0x31, 0x32,\n\t}\n\tv4Len := fmt.Sprintf(\"%d\", len(v4))\n\tv4Cap := fmt.Sprintf(\"%d\", cap(v4))\n\tnv4 := (*[]byte)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"[]uint8\"\n\tv4s := \"(len=\" + v4Len + \" cap=\" + v4Cap + \") \" +\n\t\t\"{\\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20\" +\n\t\t\" |............... |\\n\" +\n\t\t\" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30\" +\n\t\t\" |!\\\"#$%&'()*+,-./0|\\n\" +\n\t\t\" 00000020 31 32 \" +\n\t\t\" |12|\\n}\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\taddDumpTest(pv4, \"(*\"+v4t+\")(\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(&pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(nv4, \"(*\"+v4t+\")()\\n\")\n\n\t// Nil slice.\n\tv5 := []int(nil)\n\tnv5 := (*[]int)(nil)\n\tpv5 := &v5\n\tv5Addr := fmt.Sprintf(\"%p\", pv5)\n\tpv5Addr := fmt.Sprintf(\"%p\", &pv5)\n\tv5t := \"[]int\"\n\tv5s := \"\"\n\taddDumpTest(v5, \"(\"+v5t+\") \"+v5s+\"\\n\")\n\taddDumpTest(pv5, \"(*\"+v5t+\")(\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(&pv5, \"(**\"+v5t+\")(\"+pv5Addr+\"->\"+v5Addr+\")(\"+v5s+\")\\n\")\n\taddDumpTest(nv5, \"(*\"+v5t+\")()\\n\")\n}\n\nfunc addStringDumpTests() {\n\t// Standard string.\n\tv := \"test\"\n\tvLen := fmt.Sprintf(\"%d\", len(v))\n\tnv := (*string)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"string\"\n\tvs := \"(len=\" + vLen + \") \\\"test\\\"\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n}\n\nfunc addInterfaceDumpTests() {\n\t// Nil interface.\n\tvar v interface{}\n\tnv := (*interface{})(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"interface {}\"\n\tvs := \"\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Sub-interface.\n\tv2 := interface{}(uint16(65535))\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uint16\"\n\tv2s := \"65535\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n}\n\nfunc addMapDumpTests() {\n\t// Map with string keys and int vals.\n\tk := \"one\"\n\tkk := \"two\"\n\tm := map[string]int{k: 1, kk: 2}\n\tklen := fmt.Sprintf(\"%d\", len(k)) // not kLen to shut golint up\n\tkkLen := fmt.Sprintf(\"%d\", len(kk))\n\tmLen := fmt.Sprintf(\"%d\", len(m))\n\tnilMap := map[string]int(nil)\n\tnm := (*map[string]int)(nil)\n\tpm := &m\n\tmAddr := fmt.Sprintf(\"%p\", pm)\n\tpmAddr := fmt.Sprintf(\"%p\", &pm)\n\tmt := \"map[string]int\"\n\tmt1 := \"string\"\n\tmt2 := \"int\"\n\tms := \"(len=\" + mLen + \") {\\n (\" + mt1 + \") (len=\" + klen + \") \" +\n\t\t\"\\\"one\\\": (\" + mt2 + \") 1,\\n (\" + mt1 + \") (len=\" + kkLen +\n\t\t\") \\\"two\\\": (\" + mt2 + \") 2\\n}\"\n\tms2 := \"(len=\" + mLen + \") {\\n (\" + mt1 + \") (len=\" + kkLen + \") \" +\n\t\t\"\\\"two\\\": (\" + mt2 + \") 2,\\n (\" + mt1 + \") (len=\" + klen +\n\t\t\") \\\"one\\\": (\" + mt2 + \") 1\\n}\"\n\taddDumpTest(m, \"(\"+mt+\") \"+ms+\"\\n\", \"(\"+mt+\") \"+ms2+\"\\n\")\n\taddDumpTest(pm, \"(*\"+mt+\")(\"+mAddr+\")(\"+ms+\")\\n\",\n\t\t\"(*\"+mt+\")(\"+mAddr+\")(\"+ms2+\")\\n\")\n\taddDumpTest(&pm, \"(**\"+mt+\")(\"+pmAddr+\"->\"+mAddr+\")(\"+ms+\")\\n\",\n\t\t\"(**\"+mt+\")(\"+pmAddr+\"->\"+mAddr+\")(\"+ms2+\")\\n\")\n\taddDumpTest(nm, \"(*\"+mt+\")()\\n\")\n\taddDumpTest(nilMap, \"(\"+mt+\") \\n\")\n\n\t// Map with custom formatter type on pointer receiver only keys and vals.\n\tk2 := pstringer(\"one\")\n\tv2 := pstringer(\"1\")\n\tm2 := map[pstringer]pstringer{k2: v2}\n\tk2Len := fmt.Sprintf(\"%d\", len(k2))\n\tv2Len := fmt.Sprintf(\"%d\", len(v2))\n\tm2Len := fmt.Sprintf(\"%d\", len(m2))\n\tnilMap2 := map[pstringer]pstringer(nil)\n\tnm2 := (*map[pstringer]pstringer)(nil)\n\tpm2 := &m2\n\tm2Addr := fmt.Sprintf(\"%p\", pm2)\n\tpm2Addr := fmt.Sprintf(\"%p\", &pm2)\n\tm2t := \"map[spew_test.pstringer]spew_test.pstringer\"\n\tm2t1 := \"spew_test.pstringer\"\n\tm2t2 := \"spew_test.pstringer\"\n\tm2s := \"(len=\" + m2Len + \") {\\n (\" + m2t1 + \") (len=\" + k2Len + \") \" +\n\t\t\"stringer one: (\" + m2t2 + \") (len=\" + v2Len + \") stringer 1\\n}\"\n\tif spew.UnsafeDisabled {\n\t\tm2s = \"(len=\" + m2Len + \") {\\n (\" + m2t1 + \") (len=\" + k2Len +\n\t\t\t\") \" + \"\\\"one\\\": (\" + m2t2 + \") (len=\" + v2Len +\n\t\t\t\") \\\"1\\\"\\n}\"\n\t}\n\taddDumpTest(m2, \"(\"+m2t+\") \"+m2s+\"\\n\")\n\taddDumpTest(pm2, \"(*\"+m2t+\")(\"+m2Addr+\")(\"+m2s+\")\\n\")\n\taddDumpTest(&pm2, \"(**\"+m2t+\")(\"+pm2Addr+\"->\"+m2Addr+\")(\"+m2s+\")\\n\")\n\taddDumpTest(nm2, \"(*\"+m2t+\")()\\n\")\n\taddDumpTest(nilMap2, \"(\"+m2t+\") \\n\")\n\n\t// Map with interface keys and values.\n\tk3 := \"one\"\n\tk3Len := fmt.Sprintf(\"%d\", len(k3))\n\tm3 := map[interface{}]interface{}{k3: 1}\n\tm3Len := fmt.Sprintf(\"%d\", len(m3))\n\tnilMap3 := map[interface{}]interface{}(nil)\n\tnm3 := (*map[interface{}]interface{})(nil)\n\tpm3 := &m3\n\tm3Addr := fmt.Sprintf(\"%p\", pm3)\n\tpm3Addr := fmt.Sprintf(\"%p\", &pm3)\n\tm3t := \"map[interface {}]interface {}\"\n\tm3t1 := \"string\"\n\tm3t2 := \"int\"\n\tm3s := \"(len=\" + m3Len + \") {\\n (\" + m3t1 + \") (len=\" + k3Len + \") \" +\n\t\t\"\\\"one\\\": (\" + m3t2 + \") 1\\n}\"\n\taddDumpTest(m3, \"(\"+m3t+\") \"+m3s+\"\\n\")\n\taddDumpTest(pm3, \"(*\"+m3t+\")(\"+m3Addr+\")(\"+m3s+\")\\n\")\n\taddDumpTest(&pm3, \"(**\"+m3t+\")(\"+pm3Addr+\"->\"+m3Addr+\")(\"+m3s+\")\\n\")\n\taddDumpTest(nm3, \"(*\"+m3t+\")()\\n\")\n\taddDumpTest(nilMap3, \"(\"+m3t+\") \\n\")\n\n\t// Map with nil interface value.\n\tk4 := \"nil\"\n\tk4Len := fmt.Sprintf(\"%d\", len(k4))\n\tm4 := map[string]interface{}{k4: nil}\n\tm4Len := fmt.Sprintf(\"%d\", len(m4))\n\tnilMap4 := map[string]interface{}(nil)\n\tnm4 := (*map[string]interface{})(nil)\n\tpm4 := &m4\n\tm4Addr := fmt.Sprintf(\"%p\", pm4)\n\tpm4Addr := fmt.Sprintf(\"%p\", &pm4)\n\tm4t := \"map[string]interface {}\"\n\tm4t1 := \"string\"\n\tm4t2 := \"interface {}\"\n\tm4s := \"(len=\" + m4Len + \") {\\n (\" + m4t1 + \") (len=\" + k4Len + \")\" +\n\t\t\" \\\"nil\\\": (\" + m4t2 + \") \\n}\"\n\taddDumpTest(m4, \"(\"+m4t+\") \"+m4s+\"\\n\")\n\taddDumpTest(pm4, \"(*\"+m4t+\")(\"+m4Addr+\")(\"+m4s+\")\\n\")\n\taddDumpTest(&pm4, \"(**\"+m4t+\")(\"+pm4Addr+\"->\"+m4Addr+\")(\"+m4s+\")\\n\")\n\taddDumpTest(nm4, \"(*\"+m4t+\")()\\n\")\n\taddDumpTest(nilMap4, \"(\"+m4t+\") \\n\")\n}\n\nfunc addStructDumpTests() {\n\t// Struct with primitives.\n\ttype s1 struct {\n\t\ta int8\n\t\tb uint8\n\t}\n\tv := s1{127, 255}\n\tnv := (*s1)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"spew_test.s1\"\n\tvt2 := \"int8\"\n\tvt3 := \"uint8\"\n\tvs := \"{\\n a: (\" + vt2 + \") 127,\\n b: (\" + vt3 + \") 255\\n}\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Struct that contains another struct.\n\ttype s2 struct {\n\t\ts1 s1\n\t\tb bool\n\t}\n\tv2 := s2{s1{127, 255}, true}\n\tnv2 := (*s2)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"spew_test.s2\"\n\tv2t2 := \"spew_test.s1\"\n\tv2t3 := \"int8\"\n\tv2t4 := \"uint8\"\n\tv2t5 := \"bool\"\n\tv2s := \"{\\n s1: (\" + v2t2 + \") {\\n a: (\" + v2t3 + \") 127,\\n b: (\" +\n\t\tv2t4 + \") 255\\n },\\n b: (\" + v2t5 + \") true\\n}\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n\n\t// Struct that contains custom type with Stringer pointer interface via both\n\t// exported and unexported fields.\n\ttype s3 struct {\n\t\ts pstringer\n\t\tS pstringer\n\t}\n\tv3 := s3{\"test\", \"test2\"}\n\tnv3 := (*s3)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"spew_test.s3\"\n\tv3t2 := \"spew_test.pstringer\"\n\tv3s := \"{\\n s: (\" + v3t2 + \") (len=4) stringer test,\\n S: (\" + v3t2 +\n\t\t\") (len=5) stringer test2\\n}\"\n\tv3sp := v3s\n\tif spew.UnsafeDisabled {\n\t\tv3s = \"{\\n s: (\" + v3t2 + \") (len=4) \\\"test\\\",\\n S: (\" +\n\t\t\tv3t2 + \") (len=5) \\\"test2\\\"\\n}\"\n\t\tv3sp = \"{\\n s: (\" + v3t2 + \") (len=4) \\\"test\\\",\\n S: (\" +\n\t\t\tv3t2 + \") (len=5) stringer test2\\n}\"\n\t}\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3sp+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3sp+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n\n\t// Struct that contains embedded struct and field to same struct.\n\te := embed{\"embedstr\"}\n\teLen := fmt.Sprintf(\"%d\", len(\"embedstr\"))\n\tv4 := embedwrap{embed: &e, e: &e}\n\tnv4 := (*embedwrap)(nil)\n\tpv4 := &v4\n\teAddr := fmt.Sprintf(\"%p\", &e)\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"spew_test.embedwrap\"\n\tv4t2 := \"spew_test.embed\"\n\tv4t3 := \"string\"\n\tv4s := \"{\\n embed: (*\" + v4t2 + \")(\" + eAddr + \")({\\n a: (\" + v4t3 +\n\t\t\") (len=\" + eLen + \") \\\"embedstr\\\"\\n }),\\n e: (*\" + v4t2 +\n\t\t\")(\" + eAddr + \")({\\n a: (\" + v4t3 + \") (len=\" + eLen + \")\" +\n\t\t\" \\\"embedstr\\\"\\n })\\n}\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\taddDumpTest(pv4, \"(*\"+v4t+\")(\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(&pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")(\"+v4s+\")\\n\")\n\taddDumpTest(nv4, \"(*\"+v4t+\")()\\n\")\n}\n\nfunc addUintptrDumpTests() {\n\t// Null pointer.\n\tv := uintptr(0)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"uintptr\"\n\tvs := \"\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\n\t// Address of real variable.\n\ti := 1\n\tv2 := uintptr(unsafe.Pointer(&i))\n\tnv2 := (*uintptr)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uintptr\"\n\tv2s := fmt.Sprintf(\"%p\", &i)\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n}\n\nfunc addUnsafePointerDumpTests() {\n\t// Null pointer.\n\tv := unsafe.Pointer(nil)\n\tnv := (*unsafe.Pointer)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"unsafe.Pointer\"\n\tvs := \"\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Address of real variable.\n\ti := 1\n\tv2 := unsafe.Pointer(&i)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"unsafe.Pointer\"\n\tv2s := fmt.Sprintf(\"%p\", &i)\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n}\n\nfunc addChanDumpTests() {\n\t// Nil channel.\n\tvar v chan int\n\tpv := &v\n\tnv := (*chan int)(nil)\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"chan int\"\n\tvs := \"\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Real channel.\n\tv2 := make(chan int)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"chan int\"\n\tv2s := fmt.Sprintf(\"%p\", v2)\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n}\n\nfunc addFuncDumpTests() {\n\t// Function with no params and no returns.\n\tv := addIntDumpTests\n\tnv := (*func())(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"func()\"\n\tvs := fmt.Sprintf(\"%p\", v)\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n\n\t// Function with param and no returns.\n\tv2 := TestDump\n\tnv2 := (*func(*testing.T))(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"func(*testing.T)\"\n\tv2s := fmt.Sprintf(\"%p\", v2)\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s+\")\\n\")\n\taddDumpTest(nv2, \"(*\"+v2t+\")()\\n\")\n\n\t// Function with multiple params and multiple returns.\n\tvar v3 = func(i int, s string) (b bool, err error) {\n\t\treturn true, nil\n\t}\n\tnv3 := (*func(int, string) (bool, error))(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"func(int, string) (bool, error)\"\n\tv3s := fmt.Sprintf(\"%p\", v3)\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s+\")\\n\")\n\taddDumpTest(nv3, \"(*\"+v3t+\")()\\n\")\n}\n\nfunc addCircularDumpTests() {\n\t// Struct that is circular through self referencing.\n\ttype circular struct {\n\t\tc *circular\n\t}\n\tv := circular{nil}\n\tv.c = &v\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"spew_test.circular\"\n\tvs := \"{\\n c: (*\" + vt + \")(\" + vAddr + \")({\\n c: (*\" + vt + \")(\" +\n\t\tvAddr + \")()\\n })\\n}\"\n\tvs2 := \"{\\n c: (*\" + vt + \")(\" + vAddr + \")()\\n}\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs2+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs2+\")\\n\")\n\n\t// Structs that are circular through cross referencing.\n\tv2 := xref1{nil}\n\tts2 := xref2{&v2}\n\tv2.ps2 = &ts2\n\tpv2 := &v2\n\tts2Addr := fmt.Sprintf(\"%p\", &ts2)\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"spew_test.xref1\"\n\tv2t2 := \"spew_test.xref2\"\n\tv2s := \"{\\n ps2: (*\" + v2t2 + \")(\" + ts2Addr + \")({\\n ps1: (*\" + v2t +\n\t\t\")(\" + v2Addr + \")({\\n ps2: (*\" + v2t2 + \")(\" + ts2Addr +\n\t\t\")()\\n })\\n })\\n}\"\n\tv2s2 := \"{\\n ps2: (*\" + v2t2 + \")(\" + ts2Addr + \")({\\n ps1: (*\" + v2t +\n\t\t\")(\" + v2Addr + \")()\\n })\\n}\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\taddDumpTest(pv2, \"(*\"+v2t+\")(\"+v2Addr+\")(\"+v2s2+\")\\n\")\n\taddDumpTest(&pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")(\"+v2s2+\")\\n\")\n\n\t// Structs that are indirectly circular.\n\tv3 := indirCir1{nil}\n\ttic2 := indirCir2{nil}\n\ttic3 := indirCir3{&v3}\n\ttic2.ps3 = &tic3\n\tv3.ps2 = &tic2\n\tpv3 := &v3\n\ttic2Addr := fmt.Sprintf(\"%p\", &tic2)\n\ttic3Addr := fmt.Sprintf(\"%p\", &tic3)\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"spew_test.indirCir1\"\n\tv3t2 := \"spew_test.indirCir2\"\n\tv3t3 := \"spew_test.indirCir3\"\n\tv3s := \"{\\n ps2: (*\" + v3t2 + \")(\" + tic2Addr + \")({\\n ps3: (*\" + v3t3 +\n\t\t\")(\" + tic3Addr + \")({\\n ps1: (*\" + v3t + \")(\" + v3Addr +\n\t\t\")({\\n ps2: (*\" + v3t2 + \")(\" + tic2Addr +\n\t\t\")()\\n })\\n })\\n })\\n}\"\n\tv3s2 := \"{\\n ps2: (*\" + v3t2 + \")(\" + tic2Addr + \")({\\n ps3: (*\" + v3t3 +\n\t\t\")(\" + tic3Addr + \")({\\n ps1: (*\" + v3t + \")(\" + v3Addr +\n\t\t\")()\\n })\\n })\\n}\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\")\n\taddDumpTest(pv3, \"(*\"+v3t+\")(\"+v3Addr+\")(\"+v3s2+\")\\n\")\n\taddDumpTest(&pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")(\"+v3s2+\")\\n\")\n}\n\nfunc addPanicDumpTests() {\n\t// Type that panics in its Stringer interface.\n\tv := panicer(127)\n\tnv := (*panicer)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"spew_test.panicer\"\n\tvs := \"(PANIC=test panic)127\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n}\n\nfunc addErrorDumpTests() {\n\t// Type that has a custom Error interface.\n\tv := customError(127)\n\tnv := (*customError)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"spew_test.customError\"\n\tvs := \"error: 127\"\n\taddDumpTest(v, \"(\"+vt+\") \"+vs+\"\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(*\"+vt+\")()\\n\")\n}\n\n// TestDump executes all of the tests described by dumpTests.\nfunc TestDump(t *testing.T) {\n\t// Setup tests.\n\taddIntDumpTests()\n\taddUintDumpTests()\n\taddBoolDumpTests()\n\taddFloatDumpTests()\n\taddComplexDumpTests()\n\taddArrayDumpTests()\n\taddSliceDumpTests()\n\taddStringDumpTests()\n\taddInterfaceDumpTests()\n\taddMapDumpTests()\n\taddStructDumpTests()\n\taddUintptrDumpTests()\n\taddUnsafePointerDumpTests()\n\taddChanDumpTests()\n\taddFuncDumpTests()\n\taddCircularDumpTests()\n\taddPanicDumpTests()\n\taddErrorDumpTests()\n\taddCgoDumpTests()\n\n\tt.Logf(\"Running %d tests\", len(dumpTests))\n\tfor i, test := range dumpTests {\n\t\tbuf := new(bytes.Buffer)\n\t\tspew.Fdump(buf, test.in)\n\t\ts := buf.String()\n\t\tif testFailed(s, test.wants) {\n\t\t\tt.Errorf(\"Dump #%d\\n got: %s %s\", i, s, stringizeWants(test.wants))\n\t\t\tcontinue\n\t\t}\n\t}\n}\n\nfunc TestDumpSortedKeys(t *testing.T) {\n\tcfg := spew.ConfigState{SortKeys: true}\n\ts := cfg.Sdump(map[int]string{1: \"1\", 3: \"3\", 2: \"2\"})\n\texpected := \"(map[int]string) (len=3) {\\n(int) 1: (string) (len=1) \" +\n\t\t\"\\\"1\\\",\\n(int) 2: (string) (len=1) \\\"2\\\",\\n(int) 3: (string) \" +\n\t\t\"(len=1) \\\"3\\\"\\n\" +\n\t\t\"}\\n\"\n\tif s != expected {\n\t\tt.Errorf(\"Sorted keys mismatch:\\n %v %v\", s, expected)\n\t}\n\n\ts = cfg.Sdump(map[stringer]int{\"1\": 1, \"3\": 3, \"2\": 2})\n\texpected = \"(map[spew_test.stringer]int) (len=3) {\\n\" +\n\t\t\"(spew_test.stringer) (len=1) stringer 1: (int) 1,\\n\" +\n\t\t\"(spew_test.stringer) (len=1) stringer 2: (int) 2,\\n\" +\n\t\t\"(spew_test.stringer) (len=1) stringer 3: (int) 3\\n\" +\n\t\t\"}\\n\"\n\tif s != expected {\n\t\tt.Errorf(\"Sorted keys mismatch:\\n %v %v\", s, expected)\n\t}\n\n\ts = cfg.Sdump(map[pstringer]int{pstringer(\"1\"): 1, pstringer(\"3\"): 3, pstringer(\"2\"): 2})\n\texpected = \"(map[spew_test.pstringer]int) (len=3) {\\n\" +\n\t\t\"(spew_test.pstringer) (len=1) stringer 1: (int) 1,\\n\" +\n\t\t\"(spew_test.pstringer) (len=1) stringer 2: (int) 2,\\n\" +\n\t\t\"(spew_test.pstringer) (len=1) stringer 3: (int) 3\\n\" +\n\t\t\"}\\n\"\n\tif spew.UnsafeDisabled {\n\t\texpected = \"(map[spew_test.pstringer]int) (len=3) {\\n\" +\n\t\t\t\"(spew_test.pstringer) (len=1) \\\"1\\\": (int) 1,\\n\" +\n\t\t\t\"(spew_test.pstringer) (len=1) \\\"2\\\": (int) 2,\\n\" +\n\t\t\t\"(spew_test.pstringer) (len=1) \\\"3\\\": (int) 3\\n\" +\n\t\t\t\"}\\n\"\n\t}\n\tif s != expected {\n\t\tt.Errorf(\"Sorted keys mismatch:\\n %v %v\", s, expected)\n\t}\n\n\ts = cfg.Sdump(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})\n\texpected = \"(map[spew_test.customError]int) (len=3) {\\n\" +\n\t\t\"(spew_test.customError) error: 1: (int) 1,\\n\" +\n\t\t\"(spew_test.customError) error: 2: (int) 2,\\n\" +\n\t\t\"(spew_test.customError) error: 3: (int) 3\\n\" +\n\t\t\"}\\n\"\n\tif s != expected {\n\t\tt.Errorf(\"Sorted keys mismatch:\\n %v %v\", s, expected)\n\t}\n\n}\n"
},
{
"path": "internal/spew/dumpcgo_test.go",
"content": "// Copyright (c) 2013-2016 Dave Collins \n//\n// Permission to use, copy, modify, and distribute this software for any\n// purpose with or without fee is hereby granted, provided that the above\n// copyright notice and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n// NOTE: Due to the following build constraints, this file will only be compiled\n// when both cgo is supported and \"-tags testcgo\" is added to the go test\n// command line. This means the cgo tests are only added (and hence run) when\n// specifically requested. This configuration is used because spew itself\n// does not require cgo to run even though it does handle certain cgo types\n// specially. Rather than forcing all clients to require cgo and an external\n// C compiler just to run the tests, this scheme makes them optional.\n//go:build cgo && testcgo\n// +build cgo,testcgo\n\npackage spew_test\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/expr-lang/expr/internal/spew/testdata\"\n)\n\nfunc addCgoDumpTests() {\n\t// C char pointer.\n\tv := testdata.GetCgoCharPointer()\n\tnv := testdata.GetCgoNullCharPointer()\n\tpv := &v\n\tvcAddr := fmt.Sprintf(\"%p\", v)\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"*testdata._Ctype_char\"\n\tvs := \"116\"\n\taddDumpTest(v, \"(\"+vt+\")(\"+vcAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(pv, \"(*\"+vt+\")(\"+vAddr+\"->\"+vcAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(&pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\"->\"+vcAddr+\")(\"+vs+\")\\n\")\n\taddDumpTest(nv, \"(\"+vt+\")()\\n\")\n\n\t// C char array.\n\tv2, v2l, v2c := testdata.GetCgoCharArray()\n\tv2Len := fmt.Sprintf(\"%d\", v2l)\n\tv2Cap := fmt.Sprintf(\"%d\", v2c)\n\tv2t := \"[6]testdata._Ctype_char\"\n\tv2s := \"(len=\" + v2Len + \" cap=\" + v2Cap + \") \" +\n\t\t\"{\\n 00000000 74 65 73 74 32 00 \" +\n\t\t\" |test2.|\\n}\"\n\taddDumpTest(v2, \"(\"+v2t+\") \"+v2s+\"\\n\")\n\n\t// C unsigned char array.\n\tv3, v3l, v3c := testdata.GetCgoUnsignedCharArray()\n\tv3Len := fmt.Sprintf(\"%d\", v3l)\n\tv3Cap := fmt.Sprintf(\"%d\", v3c)\n\tv3t := \"[6]testdata._Ctype_unsignedchar\"\n\tv3t2 := \"[6]testdata._Ctype_uchar\"\n\tv3s := \"(len=\" + v3Len + \" cap=\" + v3Cap + \") \" +\n\t\t\"{\\n 00000000 74 65 73 74 33 00 \" +\n\t\t\" |test3.|\\n}\"\n\taddDumpTest(v3, \"(\"+v3t+\") \"+v3s+\"\\n\", \"(\"+v3t2+\") \"+v3s+\"\\n\")\n\n\t// C signed char array.\n\tv4, v4l, v4c := testdata.GetCgoSignedCharArray()\n\tv4Len := fmt.Sprintf(\"%d\", v4l)\n\tv4Cap := fmt.Sprintf(\"%d\", v4c)\n\tv4t := \"[6]testdata._Ctype_schar\"\n\tv4t2 := \"testdata._Ctype_schar\"\n\tv4s := \"(len=\" + v4Len + \" cap=\" + v4Cap + \") \" +\n\t\t\"{\\n (\" + v4t2 + \") 116,\\n (\" + v4t2 + \") 101,\\n (\" + v4t2 +\n\t\t\") 115,\\n (\" + v4t2 + \") 116,\\n (\" + v4t2 + \") 52,\\n (\" + v4t2 +\n\t\t\") 0\\n}\"\n\taddDumpTest(v4, \"(\"+v4t+\") \"+v4s+\"\\n\")\n\n\t// C uint8_t array.\n\tv5, v5l, v5c := testdata.GetCgoUint8tArray()\n\tv5Len := fmt.Sprintf(\"%d\", v5l)\n\tv5Cap := fmt.Sprintf(\"%d\", v5c)\n\tv5t := \"[6]testdata._Ctype_uint8_t\"\n\tv5t2 := \"[6]testdata._Ctype_uchar\"\n\tv5s := \"(len=\" + v5Len + \" cap=\" + v5Cap + \") \" +\n\t\t\"{\\n 00000000 74 65 73 74 35 00 \" +\n\t\t\" |test5.|\\n}\"\n\taddDumpTest(v5, \"(\"+v5t+\") \"+v5s+\"\\n\", \"(\"+v5t2+\") \"+v5s+\"\\n\")\n\n\t// C typedefed unsigned char array.\n\tv6, v6l, v6c := testdata.GetCgoTypedefedUnsignedCharArray()\n\tv6Len := fmt.Sprintf(\"%d\", v6l)\n\tv6Cap := fmt.Sprintf(\"%d\", v6c)\n\tv6t := \"[6]testdata._Ctype_custom_uchar_t\"\n\tv6t2 := \"[6]testdata._Ctype_uchar\"\n\tv6s := \"(len=\" + v6Len + \" cap=\" + v6Cap + \") \" +\n\t\t\"{\\n 00000000 74 65 73 74 36 00 \" +\n\t\t\" |test6.|\\n}\"\n\taddDumpTest(v6, \"(\"+v6t+\") \"+v6s+\"\\n\", \"(\"+v6t2+\") \"+v6s+\"\\n\")\n}\n"
},
{
"path": "internal/spew/dumpnocgo_test.go",
"content": "// Copyright (c) 2013 Dave Collins \n//\n// Permission to use, copy, modify, and distribute this software for any\n// purpose with or without fee is hereby granted, provided that the above\n// copyright notice and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n// NOTE: Due to the following build constraints, this file will only be compiled\n// when either cgo is not supported or \"-tags testcgo\" is not added to the go\n// test command line. This file intentionally does not setup any cgo tests in\n// this scenario.\n//go:build !cgo || !testcgo\n// +build !cgo !testcgo\n\npackage spew_test\n\nfunc addCgoDumpTests() {\n\t// Don't add any tests for cgo since this file is only compiled when\n\t// there should not be any cgo tests.\n}\n"
},
{
"path": "internal/spew/example_test.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew_test\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/expr-lang/expr/internal/spew\"\n)\n\ntype Flag int\n\nconst (\n\tflagOne Flag = iota\n\tflagTwo\n)\n\nvar flagStrings = map[Flag]string{\n\tflagOne: \"flagOne\",\n\tflagTwo: \"flagTwo\",\n}\n\nfunc (f Flag) String() string {\n\tif s, ok := flagStrings[f]; ok {\n\t\treturn s\n\t}\n\treturn fmt.Sprintf(\"Unknown flag (%d)\", int(f))\n}\n\ntype Bar struct {\n\tdata uintptr\n}\n\ntype Foo struct {\n\tunexportedField Bar\n\tExportedField map[interface{}]interface{}\n}\n\n// This example demonstrates how to use Dump to dump variables to stdout.\nfunc ExampleDump() {\n\t// The following package level declarations are assumed for this example:\n\t/*\n\t\ttype Flag int\n\n\t\tconst (\n\t\t\tflagOne Flag = iota\n\t\t\tflagTwo\n\t\t)\n\n\t\tvar flagStrings = map[Flag]string{\n\t\t\tflagOne: \"flagOne\",\n\t\t\tflagTwo: \"flagTwo\",\n\t\t}\n\n\t\tfunc (f Flag) String() string {\n\t\t\tif s, ok := flagStrings[f]; ok {\n\t\t\t\treturn s\n\t\t\t}\n\t\t\treturn fmt.Sprintf(\"Unknown flag (%d)\", int(f))\n\t\t}\n\n\t\ttype Bar struct {\n\t\t\tdata uintptr\n\t\t}\n\n\t\ttype Foo struct {\n\t\t\tunexportedField Bar\n\t\t\tExportedField map[interface{}]interface{}\n\t\t}\n\t*/\n\n\t// Setup some sample data structures for the example.\n\tbar := Bar{uintptr(0)}\n\ts1 := Foo{bar, map[interface{}]interface{}{\"one\": true}}\n\tf := Flag(5)\n\tb := []byte{\n\t\t0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,\n\t\t0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,\n\t\t0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,\n\t\t0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,\n\t\t0x31, 0x32,\n\t}\n\n\t// Dump!\n\tspew.Dump(s1, f, b)\n\n\t// Output:\n\t// (spew_test.Foo) {\n\t// unexportedField: (spew_test.Bar) {\n\t// data: (uintptr) \n\t// },\n\t// ExportedField: (map[interface {}]interface {}) (len=1) {\n\t// (string) (len=3) \"one\": (bool) true\n\t// }\n\t// }\n\t// (spew_test.Flag) Unknown flag (5)\n\t// ([]uint8) (len=34 cap=34) {\n\t// 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |\n\t// 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!\"#$%&'()*+,-./0|\n\t// 00000020 31 32 |12|\n\t// }\n\t//\n}\n\n// This example demonstrates how to use Printf to display a variable with a\n// format string and inline formatting.\nfunc ExamplePrintf() {\n\t// Create a double pointer to a uint 8.\n\tui8 := uint8(5)\n\tpui8 := &ui8\n\tppui8 := &pui8\n\n\t// Create a circular data type.\n\ttype circular struct {\n\t\tui8 uint8\n\t\tc *circular\n\t}\n\tc := circular{ui8: 1}\n\tc.c = &c\n\n\t// Print!\n\tspew.Printf(\"ppui8: %v\\n\", ppui8)\n\tspew.Printf(\"circular: %v\\n\", c)\n\n\t// Output:\n\t// ppui8: <**>5\n\t// circular: {1 <*>{1 <*>}}\n}\n\n// This example demonstrates how to use a ConfigState.\nfunc ExampleConfigState() {\n\t// Modify the indent level of the ConfigState only. The global\n\t// configuration is not modified.\n\tscs := spew.ConfigState{Indent: \"\\t\"}\n\n\t// Output using the ConfigState instance.\n\tv := map[string]int{\"one\": 1}\n\tscs.Printf(\"v: %v\\n\", v)\n\tscs.Dump(v)\n\n\t// Output:\n\t// v: map[one:1]\n\t// (map[string]int) (len=1) {\n\t// \t(string) (len=3) \"one\": (int) 1\n\t// }\n}\n\n// This example demonstrates how to use ConfigState.Dump to dump variables to\n// stdout\nfunc ExampleConfigState_Dump() {\n\t// See the top-level Dump example for details on the types used in this\n\t// example.\n\n\t// Create two ConfigState instances with different indentation.\n\tscs := spew.ConfigState{Indent: \"\\t\"}\n\tscs2 := spew.ConfigState{Indent: \" \"}\n\n\t// Setup some sample data structures for the example.\n\tbar := Bar{uintptr(0)}\n\ts1 := Foo{bar, map[interface{}]interface{}{\"one\": true}}\n\n\t// Dump using the ConfigState instances.\n\tscs.Dump(s1)\n\tscs2.Dump(s1)\n\n\t// Output:\n\t// (spew_test.Foo) {\n\t// \tunexportedField: (spew_test.Bar) {\n\t// \t\tdata: (uintptr) \n\t// \t},\n\t// \tExportedField: (map[interface {}]interface {}) (len=1) {\n\t//\t\t(string) (len=3) \"one\": (bool) true\n\t// \t}\n\t// }\n\t// (spew_test.Foo) {\n\t// unexportedField: (spew_test.Bar) {\n\t// data: (uintptr) \n\t// },\n\t// ExportedField: (map[interface {}]interface {}) (len=1) {\n\t// (string) (len=3) \"one\": (bool) true\n\t// }\n\t// }\n\t//\n}\n\n// This example demonstrates how to use ConfigState.Printf to display a variable\n// with a format string and inline formatting.\nfunc ExampleConfigState_Printf() {\n\t// See the top-level Dump example for details on the types used in this\n\t// example.\n\n\t// Create two ConfigState instances and modify the method handling of the\n\t// first ConfigState only.\n\tscs := spew.NewDefaultConfig()\n\tscs2 := spew.NewDefaultConfig()\n\tscs.DisableMethods = true\n\n\t// Alternatively\n\t// scs := spew.ConfigState{Indent: \" \", DisableMethods: true}\n\t// scs2 := spew.ConfigState{Indent: \" \"}\n\n\t// This is of type Flag which implements a Stringer and has raw value 1.\n\tf := flagTwo\n\n\t// Dump using the ConfigState instances.\n\tscs.Printf(\"f: %v\\n\", f)\n\tscs2.Printf(\"f: %v\\n\", f)\n\n\t// Output:\n\t// f: 1\n\t// f: flagTwo\n}\n"
},
{
"path": "internal/spew/format.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\npackage spew\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// supportedFlags is a list of all the character flags supported by fmt package.\nconst supportedFlags = \"0-+# \"\n\n// formatState implements the fmt.Formatter interface and contains information\n// about the state of a formatting operation. The NewFormatter function can\n// be used to get a new Formatter which can be used directly as arguments\n// in standard fmt package printing calls.\ntype formatState struct {\n\tvalue interface{}\n\tfs fmt.State\n\tdepth int\n\tpointers map[uintptr]int\n\tignoreNextType bool\n\tcs *ConfigState\n}\n\n// buildDefaultFormat recreates the original format string without precision\n// and width information to pass in to fmt.Sprintf in the case of an\n// unrecognized type. Unless new types are added to the language, this\n// function won't ever be called.\nfunc (f *formatState) buildDefaultFormat() (format string) {\n\tbuf := bytes.NewBuffer(percentBytes)\n\n\tfor _, flag := range supportedFlags {\n\t\tif f.fs.Flag(int(flag)) {\n\t\t\tbuf.WriteRune(flag)\n\t\t}\n\t}\n\n\tbuf.WriteRune('v')\n\n\tformat = buf.String()\n\treturn format\n}\n\n// constructOrigFormat recreates the original format string including precision\n// and width information to pass along to the standard fmt package. This allows\n// automatic deferral of all format strings this package doesn't support.\nfunc (f *formatState) constructOrigFormat(verb rune) (format string) {\n\tbuf := bytes.NewBuffer(percentBytes)\n\n\tfor _, flag := range supportedFlags {\n\t\tif f.fs.Flag(int(flag)) {\n\t\t\tbuf.WriteRune(flag)\n\t\t}\n\t}\n\n\tif width, ok := f.fs.Width(); ok {\n\t\tbuf.WriteString(strconv.Itoa(width))\n\t}\n\n\tif precision, ok := f.fs.Precision(); ok {\n\t\tbuf.Write(precisionBytes)\n\t\tbuf.WriteString(strconv.Itoa(precision))\n\t}\n\n\tbuf.WriteRune(verb)\n\n\tformat = buf.String()\n\treturn format\n}\n\n// unpackValue returns values inside of non-nil interfaces when possible and\n// ensures that types for values which have been unpacked from an interface\n// are displayed when the show types flag is also set.\n// This is useful for data types like structs, arrays, slices, and maps which\n// can contain varying types packed inside an interface.\nfunc (f *formatState) unpackValue(v reflect.Value) reflect.Value {\n\tif v.Kind() == reflect.Interface {\n\t\tf.ignoreNextType = false\n\t\tif !v.IsNil() {\n\t\t\tv = v.Elem()\n\t\t}\n\t}\n\treturn v\n}\n\n// formatPtr handles formatting of pointers by indirecting them as necessary.\nfunc (f *formatState) formatPtr(v reflect.Value) {\n\t// Display nil if top level pointer is nil.\n\tshowTypes := f.fs.Flag('#')\n\tif v.IsNil() && (!showTypes || f.ignoreNextType) {\n\t\tf.fs.Write(nilAngleBytes)\n\t\treturn\n\t}\n\n\t// Remove pointers at or below the current depth from map used to detect\n\t// circular refs.\n\tfor k, depth := range f.pointers {\n\t\tif depth >= f.depth {\n\t\t\tdelete(f.pointers, k)\n\t\t}\n\t}\n\n\t// Keep list of all dereferenced pointers to possibly show later.\n\tpointerChain := make([]uintptr, 0)\n\n\t// Figure out how many levels of indirection there are by dereferencing\n\t// pointers and unpacking interfaces down the chain while detecting circular\n\t// references.\n\tnilFound := false\n\tcycleFound := false\n\tindirects := 0\n\tve := v\n\tfor ve.Kind() == reflect.Ptr {\n\t\tif ve.IsNil() {\n\t\t\tnilFound = true\n\t\t\tbreak\n\t\t}\n\t\tindirects++\n\t\taddr := ve.Pointer()\n\t\tpointerChain = append(pointerChain, addr)\n\t\tif pd, ok := f.pointers[addr]; ok && pd < f.depth {\n\t\t\tcycleFound = true\n\t\t\tindirects--\n\t\t\tbreak\n\t\t}\n\t\tf.pointers[addr] = f.depth\n\n\t\tve = ve.Elem()\n\t\tif ve.Kind() == reflect.Interface {\n\t\t\tif ve.IsNil() {\n\t\t\t\tnilFound = true\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tve = ve.Elem()\n\t\t}\n\t}\n\n\t// Display type or indirection level depending on flags.\n\tif showTypes && !f.ignoreNextType {\n\t\tf.fs.Write(openParenBytes)\n\t\tf.fs.Write(bytes.Repeat(asteriskBytes, indirects))\n\t\tf.fs.Write([]byte(ve.Type().String()))\n\t\tf.fs.Write(closeParenBytes)\n\t} else {\n\t\tif nilFound || cycleFound {\n\t\t\tindirects += strings.Count(ve.Type().String(), \"*\")\n\t\t}\n\t\tf.fs.Write(openAngleBytes)\n\t\tf.fs.Write([]byte(strings.Repeat(\"*\", indirects)))\n\t\tf.fs.Write(closeAngleBytes)\n\t}\n\n\t// Display pointer information depending on flags.\n\tif f.fs.Flag('+') && (len(pointerChain) > 0) {\n\t\tf.fs.Write(openParenBytes)\n\t\tfor i, addr := range pointerChain {\n\t\t\tif i > 0 {\n\t\t\t\tf.fs.Write(pointerChainBytes)\n\t\t\t}\n\t\t\tprintHexPtr(f.fs, addr)\n\t\t}\n\t\tf.fs.Write(closeParenBytes)\n\t}\n\n\t// Display dereferenced value.\n\tswitch {\n\tcase nilFound:\n\t\tf.fs.Write(nilAngleBytes)\n\n\tcase cycleFound:\n\t\tf.fs.Write(circularShortBytes)\n\n\tdefault:\n\t\tf.ignoreNextType = true\n\t\tf.format(ve)\n\t}\n}\n\n// format is the main workhorse for providing the Formatter interface. It\n// uses the passed reflect value to figure out what kind of object we are\n// dealing with and formats it appropriately. It is a recursive function,\n// however circular data structures are detected and handled properly.\nfunc (f *formatState) format(v reflect.Value) {\n\t// Handle invalid reflect values immediately.\n\tkind := v.Kind()\n\tif kind == reflect.Invalid {\n\t\tf.fs.Write(invalidAngleBytes)\n\t\treturn\n\t}\n\n\t// Handle pointers specially.\n\tif kind == reflect.Ptr {\n\t\tf.formatPtr(v)\n\t\treturn\n\t}\n\n\t// Print type information unless already handled elsewhere.\n\tif !f.ignoreNextType && f.fs.Flag('#') {\n\t\tf.fs.Write(openParenBytes)\n\t\tf.fs.Write([]byte(v.Type().String()))\n\t\tf.fs.Write(closeParenBytes)\n\t}\n\tf.ignoreNextType = false\n\n\t// Call Stringer/error interfaces if they exist and the handle methods\n\t// flag is enabled.\n\tif !f.cs.DisableMethods {\n\t\tif (kind != reflect.Invalid) && (kind != reflect.Interface) {\n\t\t\tif handled := handleMethods(f.cs, f.fs, v); handled {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t}\n\n\tswitch kind {\n\tcase reflect.Invalid:\n\t\t// Do nothing. We should never get here since invalid has already\n\t\t// been handled above.\n\n\tcase reflect.Bool:\n\t\tprintBool(f.fs, v.Bool())\n\n\tcase reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:\n\t\tprintInt(f.fs, v.Int(), 10)\n\n\tcase reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:\n\t\tprintUint(f.fs, v.Uint(), 10)\n\n\tcase reflect.Float32:\n\t\tprintFloat(f.fs, v.Float(), 32)\n\n\tcase reflect.Float64:\n\t\tprintFloat(f.fs, v.Float(), 64)\n\n\tcase reflect.Complex64:\n\t\tprintComplex(f.fs, v.Complex(), 32)\n\n\tcase reflect.Complex128:\n\t\tprintComplex(f.fs, v.Complex(), 64)\n\n\tcase reflect.Slice:\n\t\tif v.IsNil() {\n\t\t\tf.fs.Write(nilAngleBytes)\n\t\t\tbreak\n\t\t}\n\t\tfallthrough\n\n\tcase reflect.Array:\n\t\tf.fs.Write(openBracketBytes)\n\t\tf.depth++\n\t\tif (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {\n\t\t\tf.fs.Write(maxShortBytes)\n\t\t} else {\n\t\t\tnumEntries := v.Len()\n\t\t\tfor i := 0; i < numEntries; i++ {\n\t\t\t\tif i > 0 {\n\t\t\t\t\tf.fs.Write(spaceBytes)\n\t\t\t\t}\n\t\t\t\tf.ignoreNextType = true\n\t\t\t\tf.format(f.unpackValue(v.Index(i)))\n\t\t\t}\n\t\t}\n\t\tf.depth--\n\t\tf.fs.Write(closeBracketBytes)\n\n\tcase reflect.String:\n\t\tf.fs.Write([]byte(v.String()))\n\n\tcase reflect.Interface:\n\t\t// The only time we should get here is for nil interfaces due to\n\t\t// unpackValue calls.\n\t\tif v.IsNil() {\n\t\t\tf.fs.Write(nilAngleBytes)\n\t\t}\n\n\tcase reflect.Ptr:\n\t\t// Do nothing. We should never get here since pointers have already\n\t\t// been handled above.\n\n\tcase reflect.Map:\n\t\t// nil maps should be indicated as different than empty maps\n\t\tif v.IsNil() {\n\t\t\tf.fs.Write(nilAngleBytes)\n\t\t\tbreak\n\t\t}\n\n\t\tf.fs.Write(openMapBytes)\n\t\tf.depth++\n\t\tif (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {\n\t\t\tf.fs.Write(maxShortBytes)\n\t\t} else {\n\t\t\tkeys := v.MapKeys()\n\t\t\tif f.cs.SortKeys {\n\t\t\t\tsortValues(keys, f.cs)\n\t\t\t}\n\t\t\tfor i, key := range keys {\n\t\t\t\tif i > 0 {\n\t\t\t\t\tf.fs.Write(spaceBytes)\n\t\t\t\t}\n\t\t\t\tf.ignoreNextType = true\n\t\t\t\tf.format(f.unpackValue(key))\n\t\t\t\tf.fs.Write(colonBytes)\n\t\t\t\tf.ignoreNextType = true\n\t\t\t\tf.format(f.unpackValue(v.MapIndex(key)))\n\t\t\t}\n\t\t}\n\t\tf.depth--\n\t\tf.fs.Write(closeMapBytes)\n\n\tcase reflect.Struct:\n\t\tnumFields := v.NumField()\n\t\tf.fs.Write(openBraceBytes)\n\t\tf.depth++\n\t\tif (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {\n\t\t\tf.fs.Write(maxShortBytes)\n\t\t} else {\n\t\t\tvt := v.Type()\n\t\t\tfor i := 0; i < numFields; i++ {\n\t\t\t\tif i > 0 {\n\t\t\t\t\tf.fs.Write(spaceBytes)\n\t\t\t\t}\n\t\t\t\tvtf := vt.Field(i)\n\t\t\t\tif f.fs.Flag('+') || f.fs.Flag('#') {\n\t\t\t\t\tf.fs.Write([]byte(vtf.Name))\n\t\t\t\t\tf.fs.Write(colonBytes)\n\t\t\t\t}\n\t\t\t\tf.format(f.unpackValue(v.Field(i)))\n\t\t\t}\n\t\t}\n\t\tf.depth--\n\t\tf.fs.Write(closeBraceBytes)\n\n\tcase reflect.Uintptr:\n\t\tprintHexPtr(f.fs, uintptr(v.Uint()))\n\n\tcase reflect.UnsafePointer, reflect.Chan, reflect.Func:\n\t\tprintHexPtr(f.fs, v.Pointer())\n\n\t// There were not any other types at the time this code was written, but\n\t// fall back to letting the default fmt package handle it if any get added.\n\tdefault:\n\t\tformat := f.buildDefaultFormat()\n\t\tif v.CanInterface() {\n\t\t\tfmt.Fprintf(f.fs, format, v.Interface())\n\t\t} else {\n\t\t\tfmt.Fprintf(f.fs, format, v.String())\n\t\t}\n\t}\n}\n\n// Format satisfies the fmt.Formatter interface. See NewFormatter for usage\n// details.\nfunc (f *formatState) Format(fs fmt.State, verb rune) {\n\tf.fs = fs\n\n\t// Use standard formatting for verbs that are not v.\n\tif verb != 'v' {\n\t\tformat := f.constructOrigFormat(verb)\n\t\tfmt.Fprintf(fs, format, f.value)\n\t\treturn\n\t}\n\n\tif f.value == nil {\n\t\tif fs.Flag('#') {\n\t\t\tfs.Write(interfaceBytes)\n\t\t}\n\t\tfs.Write(nilAngleBytes)\n\t\treturn\n\t}\n\n\tf.format(reflect.ValueOf(f.value))\n}\n\n// newFormatter is a helper function to consolidate the logic from the various\n// public methods which take varying config states.\nfunc newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {\n\tfs := &formatState{value: v, cs: cs}\n\tfs.pointers = make(map[uintptr]int)\n\treturn fs\n}\n\n/*\nNewFormatter returns a custom formatter that satisfies the fmt.Formatter\ninterface. As a result, it integrates cleanly with standard fmt package\nprinting functions. The formatter is useful for inline printing of smaller data\ntypes similar to the standard %v format specifier.\n\nThe custom formatter only responds to the %v (most compact), %+v (adds pointer\naddresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb\ncombinations. Any other verbs such as %x and %q will be sent to the\nstandard fmt package for formatting. In addition, the custom formatter ignores\nthe width and precision arguments (however they will still work on the format\nspecifiers not handled by the custom formatter).\n\nTypically this function shouldn't be called directly. It is much easier to make\nuse of the custom formatter by calling one of the convenience functions such as\nPrintf, Println, or Fprintf.\n*/\nfunc NewFormatter(v interface{}) fmt.Formatter {\n\treturn newFormatter(&Config, v)\n}\n"
},
{
"path": "internal/spew/format_test.go",
"content": "/*\n * Copyright (c) 2013-2016 Dave Collins \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n\n/*\nTest Summary:\nNOTE: For each test, a nil pointer, a single pointer and double pointer to the\nbase test element are also tested to ensure proper indirection across all types.\n\n- Max int8, int16, int32, int64, int\n- Max uint8, uint16, uint32, uint64, uint\n- Boolean true and false\n- Standard complex64 and complex128\n- Array containing standard ints\n- Array containing type with custom formatter on pointer receiver only\n- Array containing interfaces\n- Slice containing standard float32 values\n- Slice containing type with custom formatter on pointer receiver only\n- Slice containing interfaces\n- Nil slice\n- Standard string\n- Nil interface\n- Sub-interface\n- Map with string keys and int vals\n- Map with custom formatter type on pointer receiver only keys and vals\n- Map with interface keys and values\n- Map with nil interface value\n- Struct with primitives\n- Struct that contains another struct\n- Struct that contains custom type with Stringer pointer interface via both\n exported and unexported fields\n- Struct that contains embedded struct and field to same struct\n- Uintptr to 0 (null pointer)\n- Uintptr address of real variable\n- Unsafe.Pointer to 0 (null pointer)\n- Unsafe.Pointer to address of real variable\n- Nil channel\n- Standard int channel\n- Function with no params and no returns\n- Function with param and no returns\n- Function with multiple params and multiple returns\n- Struct that is circular through self referencing\n- Structs that are circular through cross referencing\n- Structs that are indirectly circular\n- Type that panics in its Stringer interface\n- Type that has a custom Error interface\n- %x passthrough with uint\n- %#x passthrough with uint\n- %f passthrough with precision\n- %f passthrough with width and precision\n- %d passthrough with width\n- %q passthrough with string\n*/\n\npackage spew_test\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"testing\"\n\t\"unsafe\"\n\n\t\"github.com/expr-lang/expr/internal/spew\"\n)\n\n// formatterTest is used to describe a test to be performed against NewFormatter.\ntype formatterTest struct {\n\tformat string\n\tin interface{}\n\twants []string\n}\n\n// formatterTests houses all of the tests to be performed against NewFormatter.\nvar formatterTests = make([]formatterTest, 0)\n\n// addFormatterTest is a helper method to append the passed input and desired\n// result to formatterTests.\nfunc addFormatterTest(format string, in interface{}, wants ...string) {\n\ttest := formatterTest{format, in, wants}\n\tformatterTests = append(formatterTests, test)\n}\n\nfunc addIntFormatterTests() {\n\t// Max int8.\n\tv := int8(127)\n\tnv := (*int8)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"int8\"\n\tvs := \"127\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Max int16.\n\tv2 := int16(32767)\n\tnv2 := (*int16)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"int16\"\n\tv2s := \"32767\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Max int32.\n\tv3 := int32(2147483647)\n\tnv3 := (*int32)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"int32\"\n\tv3s := \"2147483647\"\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3s)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3s)\n\taddFormatterTest(\"%v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\n\t// Max int64.\n\tv4 := int64(9223372036854775807)\n\tnv4 := (*int64)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"int64\"\n\tv4s := \"9223372036854775807\"\n\taddFormatterTest(\"%v\", v4, v4s)\n\taddFormatterTest(\"%v\", pv4, \"<*>\"+v4s)\n\taddFormatterTest(\"%v\", &pv4, \"<**>\"+v4s)\n\taddFormatterTest(\"%v\", nv4, \"\")\n\taddFormatterTest(\"%+v\", v4, v4s)\n\taddFormatterTest(\"%+v\", pv4, \"<*>(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", &pv4, \"<**>(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%#v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", pv4, \"(*\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", &pv4, \"(**\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", pv4, \"(*\"+v4t+\")(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", &pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\n\t// Max int.\n\tv5 := int(2147483647)\n\tnv5 := (*int)(nil)\n\tpv5 := &v5\n\tv5Addr := fmt.Sprintf(\"%p\", pv5)\n\tpv5Addr := fmt.Sprintf(\"%p\", &pv5)\n\tv5t := \"int\"\n\tv5s := \"2147483647\"\n\taddFormatterTest(\"%v\", v5, v5s)\n\taddFormatterTest(\"%v\", pv5, \"<*>\"+v5s)\n\taddFormatterTest(\"%v\", &pv5, \"<**>\"+v5s)\n\taddFormatterTest(\"%v\", nv5, \"\")\n\taddFormatterTest(\"%+v\", v5, v5s)\n\taddFormatterTest(\"%+v\", pv5, \"<*>(\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%+v\", &pv5, \"<**>(\"+pv5Addr+\"->\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%+v\", nv5, \"\")\n\taddFormatterTest(\"%#v\", v5, \"(\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", pv5, \"(*\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", &pv5, \"(**\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", nv5, \"(*\"+v5t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v5, \"(\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#+v\", pv5, \"(*\"+v5t+\")(\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%#+v\", &pv5, \"(**\"+v5t+\")(\"+pv5Addr+\"->\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%#+v\", nv5, \"(*\"+v5t+\")\"+\"\")\n}\n\nfunc addUintFormatterTests() {\n\t// Max uint8.\n\tv := uint8(255)\n\tnv := (*uint8)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"uint8\"\n\tvs := \"255\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Max uint16.\n\tv2 := uint16(65535)\n\tnv2 := (*uint16)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uint16\"\n\tv2s := \"65535\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Max uint32.\n\tv3 := uint32(4294967295)\n\tnv3 := (*uint32)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"uint32\"\n\tv3s := \"4294967295\"\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3s)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3s)\n\taddFormatterTest(\"%v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\n\t// Max uint64.\n\tv4 := uint64(18446744073709551615)\n\tnv4 := (*uint64)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"uint64\"\n\tv4s := \"18446744073709551615\"\n\taddFormatterTest(\"%v\", v4, v4s)\n\taddFormatterTest(\"%v\", pv4, \"<*>\"+v4s)\n\taddFormatterTest(\"%v\", &pv4, \"<**>\"+v4s)\n\taddFormatterTest(\"%v\", nv4, \"\")\n\taddFormatterTest(\"%+v\", v4, v4s)\n\taddFormatterTest(\"%+v\", pv4, \"<*>(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", &pv4, \"<**>(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%#v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", pv4, \"(*\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", &pv4, \"(**\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", pv4, \"(*\"+v4t+\")(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", &pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\n\t// Max uint.\n\tv5 := uint(4294967295)\n\tnv5 := (*uint)(nil)\n\tpv5 := &v5\n\tv5Addr := fmt.Sprintf(\"%p\", pv5)\n\tpv5Addr := fmt.Sprintf(\"%p\", &pv5)\n\tv5t := \"uint\"\n\tv5s := \"4294967295\"\n\taddFormatterTest(\"%v\", v5, v5s)\n\taddFormatterTest(\"%v\", pv5, \"<*>\"+v5s)\n\taddFormatterTest(\"%v\", &pv5, \"<**>\"+v5s)\n\taddFormatterTest(\"%v\", nv5, \"\")\n\taddFormatterTest(\"%+v\", v5, v5s)\n\taddFormatterTest(\"%+v\", pv5, \"<*>(\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%+v\", &pv5, \"<**>(\"+pv5Addr+\"->\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%+v\", nv5, \"\")\n\taddFormatterTest(\"%#v\", v5, \"(\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", pv5, \"(*\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", &pv5, \"(**\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#v\", nv5, \"(*\"+v5t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v5, \"(\"+v5t+\")\"+v5s)\n\taddFormatterTest(\"%#+v\", pv5, \"(*\"+v5t+\")(\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%#+v\", &pv5, \"(**\"+v5t+\")(\"+pv5Addr+\"->\"+v5Addr+\")\"+v5s)\n\taddFormatterTest(\"%#v\", nv5, \"(*\"+v5t+\")\"+\"\")\n}\n\nfunc addBoolFormatterTests() {\n\t// Boolean true.\n\tv := bool(true)\n\tnv := (*bool)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"bool\"\n\tvs := \"true\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Boolean false.\n\tv2 := bool(false)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"bool\"\n\tv2s := \"false\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n}\n\nfunc addFloatFormatterTests() {\n\t// Standard float32.\n\tv := float32(3.1415)\n\tnv := (*float32)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"float32\"\n\tvs := \"3.1415\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Standard float64.\n\tv2 := float64(3.1415926)\n\tnv2 := (*float64)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"float64\"\n\tv2s := \"3.1415926\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n}\n\nfunc addComplexFormatterTests() {\n\t// Standard complex64.\n\tv := complex(float32(6), -2)\n\tnv := (*complex64)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"complex64\"\n\tvs := \"(6-2i)\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Standard complex128.\n\tv2 := complex(float64(-6), 2)\n\tnv2 := (*complex128)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"complex128\"\n\tv2s := \"(-6+2i)\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n}\n\nfunc addArrayFormatterTests() {\n\t// Array containing standard ints.\n\tv := [3]int{1, 2, 3}\n\tnv := (*[3]int)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"[3]int\"\n\tvs := \"[1 2 3]\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Array containing type with custom formatter on pointer receiver only.\n\tv2 := [3]pstringer{\"1\", \"2\", \"3\"}\n\tnv2 := (*[3]pstringer)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"[3]spew_test.pstringer\"\n\tv2sp := \"[stringer 1 stringer 2 stringer 3]\"\n\tv2s := v2sp\n\tif spew.UnsafeDisabled {\n\t\tv2s = \"[1 2 3]\"\n\t}\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2sp)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2sp)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2sp)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2sp)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2sp)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2sp)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2sp)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2sp)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Array containing interfaces.\n\tv3 := [3]interface{}{\"one\", int(2), uint(3)}\n\tnv3 := (*[3]interface{})(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"[3]interface {}\"\n\tv3t2 := \"string\"\n\tv3t3 := \"int\"\n\tv3t4 := \"uint\"\n\tv3s := \"[one 2 3]\"\n\tv3s2 := \"[(\" + v3t2 + \")one (\" + v3t3 + \")2 (\" + v3t4 + \")3]\"\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3s)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", nv3, \"(*\"+v3t+\")\"+\"\")\n}\n\nfunc addSliceFormatterTests() {\n\t// Slice containing standard float32 values.\n\tv := []float32{3.14, 6.28, 12.56}\n\tnv := (*[]float32)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"[]float32\"\n\tvs := \"[3.14 6.28 12.56]\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Slice containing type with custom formatter on pointer receiver only.\n\tv2 := []pstringer{\"1\", \"2\", \"3\"}\n\tnv2 := (*[]pstringer)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"[]spew_test.pstringer\"\n\tv2s := \"[stringer 1 stringer 2 stringer 3]\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Slice containing interfaces.\n\tv3 := []interface{}{\"one\", int(2), uint(3), nil}\n\tnv3 := (*[]interface{})(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"[]interface {}\"\n\tv3t2 := \"string\"\n\tv3t3 := \"int\"\n\tv3t4 := \"uint\"\n\tv3t5 := \"interface {}\"\n\tv3s := \"[one 2 3 ]\"\n\tv3s2 := \"[(\" + v3t2 + \")one (\" + v3t3 + \")2 (\" + v3t4 + \")3 (\" + v3t5 +\n\t\t\")]\"\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3s)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\n\t// Nil slice.\n\tvar v4 []int\n\tnv4 := (*[]int)(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"[]int\"\n\tv4s := \"\"\n\taddFormatterTest(\"%v\", v4, v4s)\n\taddFormatterTest(\"%v\", pv4, \"<*>\"+v4s)\n\taddFormatterTest(\"%v\", &pv4, \"<**>\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%+v\", v4, v4s)\n\taddFormatterTest(\"%+v\", pv4, \"<*>(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", &pv4, \"<**>(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%#v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", pv4, \"(*\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", &pv4, \"(**\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v4, \"(\"+v4t+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", pv4, \"(*\"+v4t+\")(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", &pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%#+v\", nv4, \"(*\"+v4t+\")\"+\"\")\n}\n\nfunc addStringFormatterTests() {\n\t// Standard string.\n\tv := \"test\"\n\tnv := (*string)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"string\"\n\tvs := \"test\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n}\n\nfunc addInterfaceFormatterTests() {\n\t// Nil interface.\n\tvar v interface{}\n\tnv := (*interface{})(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"interface {}\"\n\tvs := \"\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Sub-interface.\n\tv2 := interface{}(uint16(65535))\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uint16\"\n\tv2s := \"65535\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n}\n\nfunc addMapFormatterTests() {\n\t// Map with string keys and int vals.\n\tv := map[string]int{\"one\": 1, \"two\": 2}\n\tnilMap := map[string]int(nil)\n\tnv := (*map[string]int)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"map[string]int\"\n\tvs := \"map[one:1 two:2]\"\n\tvs2 := \"map[two:2 one:1]\"\n\taddFormatterTest(\"%v\", v, vs, vs2)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs, \"<*>\"+vs2)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs, \"<**>\"+vs2)\n\taddFormatterTest(\"%+v\", nilMap, \"\")\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs, vs2)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs, \"<*>(\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs,\n\t\t\"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%+v\", nilMap, \"\")\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs, \"(\"+vt+\")\"+vs2)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs, \"(*\"+vt+\")\"+vs2)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs, \"(**\"+vt+\")\"+vs2)\n\taddFormatterTest(\"%#v\", nilMap, \"(\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs, \"(\"+vt+\")\"+vs2)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs,\n\t\t\"(*\"+vt+\")(\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs,\n\t\t\"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%#+v\", nilMap, \"(\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Map with custom formatter type on pointer receiver only keys and vals.\n\tv2 := map[pstringer]pstringer{\"one\": \"1\"}\n\tnv2 := (*map[pstringer]pstringer)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"map[spew_test.pstringer]spew_test.pstringer\"\n\tv2s := \"map[stringer one:stringer 1]\"\n\tif spew.UnsafeDisabled {\n\t\tv2s = \"map[one:1]\"\n\t}\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Map with interface keys and values.\n\tv3 := map[interface{}]interface{}{\"one\": 1}\n\tnv3 := (*map[interface{}]interface{})(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"map[interface {}]interface {}\"\n\tv3t1 := \"string\"\n\tv3t2 := \"int\"\n\tv3s := \"map[one:1]\"\n\tv3s2 := \"map[(\" + v3t1 + \")one:(\" + v3t2 + \")1]\"\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3s)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s2)\n\taddFormatterTest(\"%#+v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\n\t// Map with nil interface value\n\tv4 := map[string]interface{}{\"nil\": nil}\n\tnv4 := (*map[string]interface{})(nil)\n\tpv4 := &v4\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"map[string]interface {}\"\n\tv4t1 := \"interface {}\"\n\tv4s := \"map[nil:]\"\n\tv4s2 := \"map[nil:(\" + v4t1 + \")]\"\n\taddFormatterTest(\"%v\", v4, v4s)\n\taddFormatterTest(\"%v\", pv4, \"<*>\"+v4s)\n\taddFormatterTest(\"%v\", &pv4, \"<**>\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%+v\", v4, v4s)\n\taddFormatterTest(\"%+v\", pv4, \"<*>(\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", &pv4, \"<**>(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%#v\", v4, \"(\"+v4t+\")\"+v4s2)\n\taddFormatterTest(\"%#v\", pv4, \"(*\"+v4t+\")\"+v4s2)\n\taddFormatterTest(\"%#v\", &pv4, \"(**\"+v4t+\")\"+v4s2)\n\taddFormatterTest(\"%#v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v4, \"(\"+v4t+\")\"+v4s2)\n\taddFormatterTest(\"%#+v\", pv4, \"(*\"+v4t+\")(\"+v4Addr+\")\"+v4s2)\n\taddFormatterTest(\"%#+v\", &pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s2)\n\taddFormatterTest(\"%#+v\", nv4, \"(*\"+v4t+\")\"+\"\")\n}\n\nfunc addStructFormatterTests() {\n\t// Struct with primitives.\n\ttype s1 struct {\n\t\ta int8\n\t\tb uint8\n\t}\n\tv := s1{127, 255}\n\tnv := (*s1)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"spew_test.s1\"\n\tvt2 := \"int8\"\n\tvt3 := \"uint8\"\n\tvs := \"{127 255}\"\n\tvs2 := \"{a:127 b:255}\"\n\tvs3 := \"{a:(\" + vt2 + \")127 b:(\" + vt3 + \")255}\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs2)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs2)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs3)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs3)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs3)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs3)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs3)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs3)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Struct that contains another struct.\n\ttype s2 struct {\n\t\ts1 s1\n\t\tb bool\n\t}\n\tv2 := s2{s1{127, 255}, true}\n\tnv2 := (*s2)(nil)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"spew_test.s2\"\n\tv2t2 := \"spew_test.s1\"\n\tv2t3 := \"int8\"\n\tv2t4 := \"uint8\"\n\tv2t5 := \"bool\"\n\tv2s := \"{{127 255} true}\"\n\tv2s2 := \"{s1:{a:127 b:255} b:true}\"\n\tv2s3 := \"{s1:(\" + v2t2 + \"){a:(\" + v2t3 + \")127 b:(\" + v2t4 + \")255} b:(\" +\n\t\tv2t5 + \")true}\"\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%+v\", v2, v2s2)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s2)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s2)\n\taddFormatterTest(\"%+v\", nv2, \"\")\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s3)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s3)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s3)\n\taddFormatterTest(\"%#v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s3)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s3)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s3)\n\taddFormatterTest(\"%#+v\", nv2, \"(*\"+v2t+\")\"+\"\")\n\n\t// Struct that contains custom type with Stringer pointer interface via both\n\t// exported and unexported fields.\n\ttype s3 struct {\n\t\ts pstringer\n\t\tS pstringer\n\t}\n\tv3 := s3{\"test\", \"test2\"}\n\tnv3 := (*s3)(nil)\n\tpv3 := &v3\n\tv3Addr := fmt.Sprintf(\"%p\", pv3)\n\tpv3Addr := fmt.Sprintf(\"%p\", &pv3)\n\tv3t := \"spew_test.s3\"\n\tv3t2 := \"spew_test.pstringer\"\n\tv3s := \"{stringer test stringer test2}\"\n\tv3sp := v3s\n\tv3s2 := \"{s:stringer test S:stringer test2}\"\n\tv3s2p := v3s2\n\tv3s3 := \"{s:(\" + v3t2 + \")stringer test S:(\" + v3t2 + \")stringer test2}\"\n\tv3s3p := v3s3\n\tif spew.UnsafeDisabled {\n\t\tv3s = \"{test test2}\"\n\t\tv3sp = \"{test stringer test2}\"\n\t\tv3s2 = \"{s:test S:test2}\"\n\t\tv3s2p = \"{s:test S:stringer test2}\"\n\t\tv3s3 = \"{s:(\" + v3t2 + \")test S:(\" + v3t2 + \")test2}\"\n\t\tv3s3p = \"{s:(\" + v3t2 + \")test S:(\" + v3t2 + \")stringer test2}\"\n\t}\n\taddFormatterTest(\"%v\", v3, v3s)\n\taddFormatterTest(\"%v\", pv3, \"<*>\"+v3sp)\n\taddFormatterTest(\"%v\", &pv3, \"<**>\"+v3sp)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%+v\", v3, v3s2)\n\taddFormatterTest(\"%+v\", pv3, \"<*>(\"+v3Addr+\")\"+v3s2p)\n\taddFormatterTest(\"%+v\", &pv3, \"<**>(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s2p)\n\taddFormatterTest(\"%+v\", nv3, \"\")\n\taddFormatterTest(\"%#v\", v3, \"(\"+v3t+\")\"+v3s3)\n\taddFormatterTest(\"%#v\", pv3, \"(*\"+v3t+\")\"+v3s3p)\n\taddFormatterTest(\"%#v\", &pv3, \"(**\"+v3t+\")\"+v3s3p)\n\taddFormatterTest(\"%#v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v3, \"(\"+v3t+\")\"+v3s3)\n\taddFormatterTest(\"%#+v\", pv3, \"(*\"+v3t+\")(\"+v3Addr+\")\"+v3s3p)\n\taddFormatterTest(\"%#+v\", &pv3, \"(**\"+v3t+\")(\"+pv3Addr+\"->\"+v3Addr+\")\"+v3s3p)\n\taddFormatterTest(\"%#+v\", nv3, \"(*\"+v3t+\")\"+\"\")\n\n\t// Struct that contains embedded struct and field to same struct.\n\te := embed{\"embedstr\"}\n\tv4 := embedwrap{embed: &e, e: &e}\n\tnv4 := (*embedwrap)(nil)\n\tpv4 := &v4\n\teAddr := fmt.Sprintf(\"%p\", &e)\n\tv4Addr := fmt.Sprintf(\"%p\", pv4)\n\tpv4Addr := fmt.Sprintf(\"%p\", &pv4)\n\tv4t := \"spew_test.embedwrap\"\n\tv4t2 := \"spew_test.embed\"\n\tv4t3 := \"string\"\n\tv4s := \"{<*>{embedstr} <*>{embedstr}}\"\n\tv4s2 := \"{embed:<*>(\" + eAddr + \"){a:embedstr} e:<*>(\" + eAddr +\n\t\t\"){a:embedstr}}\"\n\tv4s3 := \"{embed:(*\" + v4t2 + \"){a:(\" + v4t3 + \")embedstr} e:(*\" + v4t2 +\n\t\t\"){a:(\" + v4t3 + \")embedstr}}\"\n\tv4s4 := \"{embed:(*\" + v4t2 + \")(\" + eAddr + \"){a:(\" + v4t3 +\n\t\t\")embedstr} e:(*\" + v4t2 + \")(\" + eAddr + \"){a:(\" + v4t3 + \")embedstr}}\"\n\taddFormatterTest(\"%v\", v4, v4s)\n\taddFormatterTest(\"%v\", pv4, \"<*>\"+v4s)\n\taddFormatterTest(\"%v\", &pv4, \"<**>\"+v4s)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%+v\", v4, v4s2)\n\taddFormatterTest(\"%+v\", pv4, \"<*>(\"+v4Addr+\")\"+v4s2)\n\taddFormatterTest(\"%+v\", &pv4, \"<**>(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s2)\n\taddFormatterTest(\"%+v\", nv4, \"\")\n\taddFormatterTest(\"%#v\", v4, \"(\"+v4t+\")\"+v4s3)\n\taddFormatterTest(\"%#v\", pv4, \"(*\"+v4t+\")\"+v4s3)\n\taddFormatterTest(\"%#v\", &pv4, \"(**\"+v4t+\")\"+v4s3)\n\taddFormatterTest(\"%#v\", nv4, \"(*\"+v4t+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v4, \"(\"+v4t+\")\"+v4s4)\n\taddFormatterTest(\"%#+v\", pv4, \"(*\"+v4t+\")(\"+v4Addr+\")\"+v4s4)\n\taddFormatterTest(\"%#+v\", &pv4, \"(**\"+v4t+\")(\"+pv4Addr+\"->\"+v4Addr+\")\"+v4s4)\n\taddFormatterTest(\"%#+v\", nv4, \"(*\"+v4t+\")\"+\"\")\n}\n\nfunc addUintptrFormatterTests() {\n\t// Null pointer.\n\tv := uintptr(0)\n\tnv := (*uintptr)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"uintptr\"\n\tvs := \"\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Address of real variable.\n\ti := 1\n\tv2 := uintptr(unsafe.Pointer(&i))\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"uintptr\"\n\tv2s := fmt.Sprintf(\"%p\", &i)\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n}\n\nfunc addUnsafePointerFormatterTests() {\n\t// Null pointer.\n\tv := unsafe.Pointer(nil)\n\tnv := (*unsafe.Pointer)(nil)\n\tpv := &v\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"unsafe.Pointer\"\n\tvs := \"\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"\")\n\taddFormatterTest(\"%#+v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#+v\", pv, \"(*\"+vt+\")(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", &pv, \"(**\"+vt+\")(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%#+v\", nv, \"(*\"+vt+\")\"+\"\")\n\n\t// Address of real variable.\n\ti := 1\n\tv2 := unsafe.Pointer(&i)\n\tpv2 := &v2\n\tv2Addr := fmt.Sprintf(\"%p\", pv2)\n\tpv2Addr := fmt.Sprintf(\"%p\", &pv2)\n\tv2t := \"unsafe.Pointer\"\n\tv2s := fmt.Sprintf(\"%p\", &i)\n\taddFormatterTest(\"%v\", v2, v2s)\n\taddFormatterTest(\"%v\", pv2, \"<*>\"+v2s)\n\taddFormatterTest(\"%v\", &pv2, \"<**>\"+v2s)\n\taddFormatterTest(\"%+v\", v2, v2s)\n\taddFormatterTest(\"%+v\", pv2, \"<*>(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%+v\", &pv2, \"<**>(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", pv2, \"(*\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#v\", &pv2, \"(**\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", v2, \"(\"+v2t+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", pv2, \"(*\"+v2t+\")(\"+v2Addr+\")\"+v2s)\n\taddFormatterTest(\"%#+v\", &pv2, \"(**\"+v2t+\")(\"+pv2Addr+\"->\"+v2Addr+\")\"+v2s)\n}\n\nfunc addChanFormatterTests() {\n\t// Nil channel.\n\tvar v chan int\n\tpv := &v\n\tnv := (*chan int)(nil)\n\tvAddr := fmt.Sprintf(\"%p\", pv)\n\tpvAddr := fmt.Sprintf(\"%p\", &pv)\n\tvt := \"chan int\"\n\tvs := \"\"\n\taddFormatterTest(\"%v\", v, vs)\n\taddFormatterTest(\"%v\", pv, \"<*>\"+vs)\n\taddFormatterTest(\"%v\", &pv, \"<**>\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%+v\", v, vs)\n\taddFormatterTest(\"%+v\", pv, \"<*>(\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", &pv, \"<**>(\"+pvAddr+\"->\"+vAddr+\")\"+vs)\n\taddFormatterTest(\"%+v\", nv, \"\")\n\taddFormatterTest(\"%#v\", v, \"(\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", pv, \"(*\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", &pv, \"(**\"+vt+\")\"+vs)\n\taddFormatterTest(\"%#v\", nv, \"(*\"+vt+\")\"+\"
![\"Zx](\"https://expr-lang.org/img/logo.png\"){kind=logo}
Expr![](\"https://expr-lang.org/img/gopher-small.png\")