Method memberNode

checker/checker.go:515–603

(node *ast.MemberNode)

}

func (v *Checker) memberNode(node *ast.MemberNode) Nature {
	// $env variable
	if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" {
		if name, ok := node.Property.(*ast.StringNode); ok {
			strict := v.config.Strict
			if node.Optional {
				// If user explicitly set optional flag, then we should not
				// throw error if field is not found (as user trying to handle
				// this case). But if user did not set optional flag, then we
				// should throw error if field is not found & v.config.Strict.
				strict = false
			}
			return v.ident(node, name.Value, strict, false /* no builtins and no functions */)
		}
		return Nature{}
	}

	base := v.visit(node.Node)
	prop := v.visit(node.Property)

	if base.IsUnknown(&v.config.NtCache) {
		return Nature{}
	}

	if name, ok := node.Property.(*ast.StringNode); ok {
		if base.Nil {
			return v.error(node, "type nil has no field %s", name.Value)
		}

		// First, check methods defined on base type itself,
		// independent of which type it is. Without dereferencing.
		if m, ok := base.MethodByName(&v.config.NtCache, name.Value); ok {
			return m
		}
	}

	base = base.Deref(&v.config.NtCache)

	switch base.Kind {
	case reflect.Map:
		// If the map key is a pointer, we should not dereference the property.
		if !prop.AssignableTo(base.Key(&v.config.NtCache)) {
			propDeref := prop.Deref(&v.config.NtCache)
			if propDeref.AssignableTo(base.Key(&v.config.NtCache)) {
				prop = propDeref
			}
		}
		if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) {
			return v.error(node.Property, "cannot use %s to get an element from %s", prop.String(), base.String())
		}
		if prop, ok := node.Property.(*ast.StringNode); ok && base.TypeData != nil {
			if field, ok := base.Fields[prop.Value]; ok {
				return field
			} else if base.Strict {
				return v.error(node.Property, "unknown field %s", prop.Value)
			}
		}
		return base.Elem(&v.config.NtCache)