Refactor types table

Author: antonmedv

checker/checker.go

@@ -1101,17 +1101,13 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Na
 
 func (v *checker) ClosureNode(node *ast.ClosureNode) Nature {
 	nt := v.visit(node.Node)
-	var out reflect.Type
+	var out []reflect.Type
 	if isUnknown(nt) {
-		out = anyType
-	} else {
-		out = nt.Type
+		out = append(out, anyType)
+	} else if !isNil(nt) {
+		out = append(out, nt.Type)
 	}
-	return Nature{Type: reflect.FuncOf(
-		[]reflect.Type{anyType},
-		[]reflect.Type{out},
-		false,
-	)}
+	return Nature{Type: reflect.FuncOf([]reflect.Type{anyType}, out, false)}
 }
 
 func (v *checker) PointerNode(node *ast.PointerNode) Nature {

checker/nature/nature.go

@@ -13,6 +13,7 @@ var (
 
 type Nature struct {
 	Type        reflect.Type
+	Nil         bool
 	SubType     SubType
 	Func        *builtin.Function
 	Method      bool
@@ -65,6 +66,12 @@ func (n Nature) Elem() Nature {
 }
 
 func (n Nature) AssignableTo(nt Nature) bool {
+	if n.Nil {
+		// Untyped nil is assignable to any interface, but implements only the empty interface.
+		if nt.Type != nil && nt.Type.Kind() == reflect.Interface {
+			return true
+		}
+	}
 	if n.Type == nil || nt.Type == nil {
 		return false
 	}
@@ -196,17 +203,30 @@ func (n Nature) List() map[string]Nature {
 		}
 	}
 
-	switch n.Type.Kind() {
+	t := deref.Type(n.Type)
+
+	switch t.Kind() {
 	case reflect.Struct:
-		for name, nt := range fields(n.Type) {
+		for name, nt := range StructFields(t) {
 			if _, ok := table[name]; ok {
 				continue
 			}
 			table[name] = nt
 		}
 
 	case reflect.Map:
+		if st, ok := n.SubType.(Map); ok {
+			for key, nt := range st.Fields {
+				if _, ok := table[key]; ok {
+					continue
+				}
+				table[key] = nt
+			}
+		}
 		v := reflect.ValueOf(n.SubType)
+		if v.Kind() != reflect.Map {
+			break
+		}
 		for _, key := range v.MapKeys() {
 			value := v.MapIndex(key)
 			if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {

checker/nature/types.go

@@ -9,7 +9,7 @@ import (
 
 func Of(value any) Nature {
 	if value == nil {
-		return Nature{}
+		return Nature{Nil: true}
 	}
 
 	v := reflect.ValueOf(value)
@@ -32,6 +32,10 @@ func Of(value any) Nature {
 			case types.Map, types.StrictMap:
 				subMap.Fields[key.String()] = Of(face)
 			default:
+				if face == nil {
+					subMap.Fields[key.String()] = Nature{Nil: true}
+					continue
+				}
 				subMap.Fields[key.String()] = Nature{Type: reflect.TypeOf(face)}
 
 			}

checker/nature/utils.go

@@ -41,7 +41,7 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) {
 	return reflect.StructField{}, false
 }
 
-func fields(t reflect.Type) map[string]Nature {
+func StructFields(t reflect.Type) map[string]Nature {
 	table := make(map[string]Nature)
 
 	t = deref.Type(t)
@@ -55,7 +55,7 @@ func fields(t reflect.Type) map[string]Nature {
 			f := t.Field(i)
 
 			if f.Anonymous {
-				for name, typ := range fields(f.Type) {
+				for name, typ := range StructFields(f.Type) {
 					if _, ok := table[name]; ok {
 						continue
 					}

checker/types.go

@@ -9,7 +9,7 @@ import (
 
 var (
 	unknown        = Nature{}
-	nilNature      = Nature{Type: reflect.TypeOf(Nil{})}
+	nilNature      = Nature{Nil: true}
 	boolNature     = Nature{Type: reflect.TypeOf(true)}
 	integerNature  = Nature{Type: reflect.TypeOf(0)}
 	floatNature    = Nature{Type: reflect.TypeOf(float64(0))}
@@ -27,14 +27,8 @@ var (
 	arrayType    = reflect.TypeOf([]any{})
 )
 
-// Nil is a special type to represent nil.
-type Nil struct{}
-
 func isNil(nt Nature) bool {
-	if nt.Type == nil {
-		return false
-	}
-	return nt.Type == nilNature.Type
+	return nt.Nil
 }
 
 func combined(l, r Nature) Nature {
@@ -71,7 +65,7 @@ func or(l, r Nature, fns ...func(Nature) bool) bool {
 
 func isUnknown(nt Nature) bool {
 	switch {
-	case nt.Type == nil:
+	case nt.Type == nil && !nt.Nil:
 		return true
 	case nt.Kind() == reflect.Interface:
 		return true

compiler/compiler.go

@@ -1198,6 +1198,9 @@ func (c *compiler) PairNode(node *ast.PairNode) {
 }
 
 func (c *compiler) derefInNeeded(node ast.Node) {
+	if node.Nature().Nil {
+		return
+	}
 	switch node.Type().Kind() {
 	case reflect.Ptr, reflect.Interface:
 		c.emit(OpDeref)

conf/config.go

@@ -82,9 +82,8 @@ func (c *Config) IsOverridden(name string) bool {
 	if _, ok := c.Functions[name]; ok {
 		return true
 	}
-	// TODO: check vars
-	//if _, ok := c.Types[name]; ok {
-	//	return true
-	//}
+	if _, ok := c.Env.Get(name); ok {
+		return true
+	}
 	return false
 }

docgen/docgen.go

@@ -5,7 +5,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/expr-lang/expr/conf"
+	"github.com/expr-lang/expr/checker/nature"
 	"github.com/expr-lang/expr/internal/deref"
 )
 
@@ -84,8 +84,8 @@ func CreateDoc(i any) *Context {
 		PkgPath:   deref.Type(reflect.TypeOf(i)).PkgPath(),
 	}
 
-	for name, t := range conf.CreateTypesTable(i) {
-		if t.Ambiguous {
+	for name, t := range nature.Of(i).List() {
+		if _, ok := c.Variables[Identifier(name)]; ok {
 			continue
 		}
 		c.Variables[Identifier(name)] = c.use(t.Type, fromMethod(t.Method))
@@ -220,8 +220,11 @@ appendix:
 			c.Types[name] = a
 		}
 
-		for name, field := range conf.FieldsFromStruct(t) {
-			if isPrivate(name) || isProtobuf(name) || field.Ambiguous {
+		for name, field := range nature.StructFields(t) {
+			if isPrivate(name) || isProtobuf(name) {
+				continue
+			}
+			if _, ok := a.Fields[Identifier(name)]; ok {
 				continue
 			}
 			a.Fields[Identifier(name)] = c.use(field.Type)

docgen/docgen_test.go

@@ -131,7 +131,7 @@ func TestCreateDoc(t *testing.T) {
 		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
-	assert.EqualValues(t, expected, doc)
+	assert.Equal(t, expected.Markdown(), doc.Markdown())
 }
 
 type A struct {
@@ -160,6 +160,9 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 				Kind: "struct",
 				Name: "A",
 			},
+			"AmbiguousField": {
+				Kind: "int",
+			},
 			"B": {
 				Kind: "struct",
 				Name: "B",
@@ -189,16 +192,17 @@ func TestCreateDoc_Ambiguous(t *testing.T) {
 			"C": {
 				Kind: "struct",
 				Fields: map[Identifier]*Type{
-					"A":       {Kind: "struct", Name: "A"},
-					"B":       {Kind: "struct", Name: "B"},
-					"OkField": {Kind: "int"},
+					"A":              {Kind: "struct", Name: "A"},
+					"AmbiguousField": {Kind: "int"},
+					"B":              {Kind: "struct", Name: "B"},
+					"OkField":        {Kind: "int"},
 				},
 			},
 		},
 		PkgPath: "github.com/expr-lang/expr/docgen_test",
 	}
 
-	assert.EqualValues(t, expected, doc)
+	assert.Equal(t, expected.Markdown(), doc.Markdown())
 }
 
 func TestCreateDoc_FromMap(t *testing.T) {
@@ -247,7 +251,7 @@ func TestCreateDoc_FromMap(t *testing.T) {
 		},
 	}
 
-	require.EqualValues(t, expected, doc)
+	require.EqualValues(t, expected.Markdown(), doc.Markdown())
 }
 
 func TestContext_Markdown(t *testing.T) {

expr_test.go

@@ -1673,10 +1673,6 @@ func TestIssue105(t *testing.T) {
 
 	_, err := expr.Compile(code, expr.Env(Env{}))
 	require.NoError(t, err)
-
-	_, err = expr.Compile(`Field == ''`, expr.Env(Env{}))
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "ambiguous identifier Field")
 }
 
 func TestIssue_nested_closures(t *testing.T) {