func isValidConditionExpression(cond ast.Expression) error {
	switch t := cond.(type) {
	case *ast.PrefixExpression:
		return isValidConditionExpression(t.Right)
	case *ast.InfixExpression:
		return isValidConditionExpression(t.Left)
	default:
		if isLiteralExpression(cond) {
			return fmt.Errorf("Could not specify literal in first expression")
		}
	}
	return nil
}
In VCL, could not specify literal in if condition expression.

if (!req.http.Cookie) { ... } // -> valid, inverse actual dentity variable (implicit type conversion will occur)
if (!false) { ... }           // -> valid, inverse boolean
if (!10) { ... }              // -> invalid, could not use with integer literal
if (!"example") { ... }       // -> invalid, could not use with string literal

So we'd check validity following function.
package linter
import (
	"fmt"
	"regexp"
	"strings"
	"github.com/ysugimoto/falco/ast"
	"github.com/ysugimoto/falco/context"
	"github.com/ysugimoto/falco/types"
)
var captureRegex = regexp.MustCompile(`\([^\)]+\)`)
var BackendPropertyTypes = map[string]types.Type{
	"dynamic":                types.BoolType,
	"share_key":              types.StringType,
	"host":                   types.StringType,
	"port":                   types.StringType,
	"ssl":                    types.BoolType,
	"ssl_cert_hostname":      types.StringType,
	"ssl_check_cert":         types.IDType,
	"ssl_sni_hostname":       types.StringType,
	"between_bytes_timeout":  types.RTimeType,
	"connect_timeout":        types.RTimeType,
	"first_byte_timeout":     types.RTimeType,
	"max_connections":        types.IntegerType,
	"host_header":            types.StringType,
	"always_use_host_header": types.BoolType,
}
var BackendProbePropertyTypes = map[string]types.Type{
	"dummy":             types.BoolType,
	"request":           types.StringType,
	"expected_response": types.IntegerType,
	"interval":          types.RTimeType,
	"timeout":           types.RTimeType,
	"window":            types.IntegerType,
	"initial":           types.IntegerType,
	"threshold":         types.IntegerType,
}
type DirectorProps struct {
	Rule     Rule
	Props    map[string]types.Type
	Requires []string
}
var DirectorPropertyTypes = map[string]DirectorProps{
	"random": {
		Rule: DIRECTOR_PROPS_RANDOM,
		Props: map[string]types.Type{
			"retries": types.IntegerType,
			"quorum":  types.StringType,
			"backend": types.BackendType,
			"weight":  types.IntegerType,
		},
		Requires: []string{"weight"},
	},
	"fallback": {
		Rule: DIRECTOR_PROPS_FALLBACK,
		Props: map[string]types.Type{
			"backend": types.BackendType,
		},
		Requires: []string{},
	},
	"hash": {
		Rule: DIRECTOR_PROPS_HASH,
		Props: map[string]types.Type{
			"quorum":  types.StringType,
			"backend": types.BackendType,
			"weight":  types.IntegerType,
		},
		Requires: []string{"weight"},
	},
	"client": {
		Rule: DIRECTOR_PROPS_CLIENT,
		Props: map[string]types.Type{
			"quorum":  types.StringType,
			"backend": types.BackendType,
			"weight":  types.IntegerType,
		},
		Requires: []string{"weight"},
	},
	"chash": {
		Rule: DIRECTOR_PROPS_CHASH,
		Props: map[string]types.Type{
			"key":             types.BackendType,  
			"seed":            types.IntegerType,
			"vnodes_per_node": types.IntegerType,
			"quorum":          types.StringType,
			"weight":          types.IntegerType,
			"id":              types.StringType,
		},
		Requires: []string{"id"},
	},
}
var ValueTypeMap = map[string]types.Type{
	"INTEGER": types.IntegerType,
	"FLOAT":   types.FloatType,
	"BOOL":    types.BoolType,
	"ACL":     types.AclType,
	"BACKEND": types.BackendType,
	"IP":      types.IPType,
	"STRING":  types.StringType,
	"ID":      types.IDType,
	"RTIME":   types.RTimeType,
	"TIME":    types.TimeType,
}
func isAlphaNumeric(r rune) bool {
	return (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_'
}
func isValidName(name string) bool {
	for _, r := range name {
		if isAlphaNumeric(r) {
			continue
		}
		return false
	}
	return true
}
func isValidVariableName(name string) bool {
	for _, r := range name {
		if isAlphaNumeric(r) || r == '.' || r == '-' || r == ':' {
			continue
		}
		return false
	}
	return true
}