Add IPv4 address parsing for CREATE ENDPOINT statements

- Add IPv4 and ListenerIPEndpointProtocolOption AST types
- Expand CreateEndpointStatement to include all endpoint fields
- Add parseIPv4Address to handle IP addresses (including float tokenization)
- Update marshaling for new types
- Enable IPv4AddressTests and Baselines90_IPv4AddressTests

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/alter_simple_statements.go

@@ -133,6 +133,27 @@ type LiteralEndpointProtocolOption struct {
 func (l *LiteralEndpointProtocolOption) node()                   {}
 func (l *LiteralEndpointProtocolOption) endpointProtocolOption() {}
 
+// IPv4 represents an IPv4 address with four octets.
+type IPv4 struct {
+	OctetOne   *IntegerLiteral
+	OctetTwo   *IntegerLiteral
+	OctetThree *IntegerLiteral
+	OctetFour  *IntegerLiteral
+}
+
+func (i *IPv4) node() {}
+
+// ListenerIPEndpointProtocolOption represents an IP address endpoint protocol option.
+type ListenerIPEndpointProtocolOption struct {
+	IsAll       bool
+	IPv4PartOne *IPv4
+	IPv4PartTwo *IPv4
+	Kind        string // TcpListenerIP, HttpListenerIP, etc.
+}
+
+func (l *ListenerIPEndpointProtocolOption) node()                   {}
+func (l *ListenerIPEndpointProtocolOption) endpointProtocolOption() {}
+
 // PayloadOption is an interface for endpoint payload options.
 type PayloadOption interface {
 	Node

ast/create_simple_statements.go

@@ -211,7 +211,13 @@ func (r *RouteOption) node() {}
 
 // CreateEndpointStatement represents a CREATE ENDPOINT statement.
 type CreateEndpointStatement struct {
-	Name *Identifier `json:"Name,omitempty"`
+	Name            *Identifier
+	State           string
+	Affinity        *EndpointAffinity
+	Protocol        string
+	ProtocolOptions []EndpointProtocolOption
+	EndpointType    string
+	PayloadOptions  []PayloadOption
 }
 
 func (s *CreateEndpointStatement) node()      {}

parser/marshal.go

@@ -17467,11 +17467,45 @@ func endpointProtocolOptionToJSON(opt ast.EndpointProtocolOption) jsonNode {
 			node["Kind"] = o.Kind
 		}
 		return node
+	case *ast.ListenerIPEndpointProtocolOption:
+		node := jsonNode{
+			"$type": "ListenerIPEndpointProtocolOption",
+			"IsAll": o.IsAll,
+		}
+		if o.IPv4PartOne != nil {
+			node["IPv4PartOne"] = ipv4ToJSON(o.IPv4PartOne)
+		}
+		if o.IPv4PartTwo != nil {
+			node["IPv4PartTwo"] = ipv4ToJSON(o.IPv4PartTwo)
+		}
+		if o.Kind != "" {
+			node["Kind"] = o.Kind
+		}
+		return node
 	default:
 		return jsonNode{"$type": "UnknownProtocolOption"}
 	}
 }
 
+func ipv4ToJSON(ip *ast.IPv4) jsonNode {
+	node := jsonNode{
+		"$type": "IPv4",
+	}
+	if ip.OctetOne != nil {
+		node["OctetOne"] = scalarExpressionToJSON(ip.OctetOne)
+	}
+	if ip.OctetTwo != nil {
+		node["OctetTwo"] = scalarExpressionToJSON(ip.OctetTwo)
+	}
+	if ip.OctetThree != nil {
+		node["OctetThree"] = scalarExpressionToJSON(ip.OctetThree)
+	}
+	if ip.OctetFour != nil {
+		node["OctetFour"] = scalarExpressionToJSON(ip.OctetFour)
+	}
+	return node
+}
+
 func payloadOptionToJSON(opt ast.PayloadOption) jsonNode {
 	switch o := opt.(type) {
 	case *ast.SoapMethod:
@@ -18765,6 +18799,32 @@ func createEndpointStatementToJSON(s *ast.CreateEndpointStatement) jsonNode {
 	if s.Name != nil {
 		node["Name"] = identifierToJSON(s.Name)
 	}
+	if s.State != "" {
+		node["State"] = s.State
+	}
+	if s.Affinity != nil {
+		node["Affinity"] = endpointAffinityToJSON(s.Affinity)
+	}
+	if s.Protocol != "" {
+		node["Protocol"] = s.Protocol
+	}
+	if len(s.ProtocolOptions) > 0 {
+		opts := make([]jsonNode, len(s.ProtocolOptions))
+		for i, opt := range s.ProtocolOptions {
+			opts[i] = endpointProtocolOptionToJSON(opt)
+		}
+		node["ProtocolOptions"] = opts
+	}
+	if s.EndpointType != "" {
+		node["EndpointType"] = s.EndpointType
+	}
+	if len(s.PayloadOptions) > 0 {
+		opts := make([]jsonNode, len(s.PayloadOptions))
+		for i, opt := range s.PayloadOptions {
+			opts[i] = payloadOptionToJSON(opt)
+		}
+		node["PayloadOptions"] = opts
+	}
 	return node
 }
 

parser/parse_ddl.go

@@ -8070,29 +8070,46 @@ func (p *Parser) parseAlterEndpointStatement() (*ast.AlterEndpointStatement, err
 					if p.curTok.Type == TokenEquals {
 						p.nextToken() // consume =
 					}
-					opt := &ast.LiteralEndpointProtocolOption{}
-					switch optName {
-					case "LISTENER_PORT":
-						opt.Kind = "TcpListenerPort"
-					case "LISTENER_IP":
-						opt.Kind = "TcpListenerIP"
-					default:
-						opt.Kind = optName
-					}
-					if p.curTok.Type == TokenNumber {
-						opt.Value = &ast.IntegerLiteral{
-							LiteralType: "Integer",
-							Value:       p.curTok.Literal,
+					if optName == "LISTENER_IP" {
+						// Parse IP address option specially
+						ipOpt := &ast.ListenerIPEndpointProtocolOption{
+							Kind: "TcpListenerIP",
 						}
-						p.nextToken()
-					} else if p.curTok.Type == TokenString {
-						opt.Value = &ast.StringLiteral{
-							LiteralType: "String",
-							Value:       p.curTok.Literal,
+						// Check for ALL or IP address in parentheses
+						if strings.ToUpper(p.curTok.Literal) == "ALL" {
+							ipOpt.IsAll = true
+							p.nextToken()
+						} else if p.curTok.Type == TokenLParen {
+							p.nextToken() // consume (
+							ipOpt.IPv4PartOne = p.parseIPv4Address()
+							if p.curTok.Type == TokenRParen {
+								p.nextToken() // consume )
+							}
 						}
-						p.nextToken()
+						stmt.ProtocolOptions = append(stmt.ProtocolOptions, ipOpt)
+					} else {
+						opt := &ast.LiteralEndpointProtocolOption{}
+						switch optName {
+						case "LISTENER_PORT":
+							opt.Kind = "TcpListenerPort"
+						default:
+							opt.Kind = optName
+						}
+						if p.curTok.Type == TokenNumber {
+							opt.Value = &ast.IntegerLiteral{
+								LiteralType: "Integer",
+								Value:       p.curTok.Literal,
+							}
+							p.nextToken()
+						} else if p.curTok.Type == TokenString {
+							opt.Value = &ast.StringLiteral{
+								LiteralType: "String",
+								Value:       p.curTok.Literal,
+							}
+							p.nextToken()
+						}
+						stmt.ProtocolOptions = append(stmt.ProtocolOptions, opt)
 					}
-					stmt.ProtocolOptions = append(stmt.ProtocolOptions, opt)
 					if p.curTok.Type == TokenComma {
 						p.nextToken()
 					}
@@ -8250,6 +8267,66 @@ func (p *Parser) parseAlterEndpointStatement() (*ast.AlterEndpointStatement, err
 	return stmt, nil
 }
 
+// parseIPv4Address parses an IPv4 address like "1.2.3.4" or "1 . 2 . 3 . 4"
+// The lexer may tokenize "1.2" as a single float token, so we need to handle that
+func (p *Parser) parseIPv4Address() *ast.IPv4 {
+	ipv4 := &ast.IPv4{}
+	var octets []string
+
+	// Collect all octets from tokens
+	for len(octets) < 4 {
+		if p.curTok.Type == TokenNumber {
+			// Check if this is a float-like number containing dots
+			literal := p.curTok.Literal
+			if strings.Contains(literal, ".") {
+				// Split by dots and add each part as an octet
+				parts := strings.Split(literal, ".")
+				for _, part := range parts {
+					if part != "" && len(octets) < 4 {
+						octets = append(octets, part)
+					}
+				}
+			} else {
+				octets = append(octets, literal)
+			}
+			p.nextToken()
+		} else if p.curTok.Type == TokenDot {
+			// Skip standalone dots
+			p.nextToken()
+		} else {
+			break
+		}
+	}
+
+	// Assign octets to the IPv4 struct
+	if len(octets) >= 1 {
+		ipv4.OctetOne = &ast.IntegerLiteral{
+			LiteralType: "Integer",
+			Value:       octets[0],
+		}
+	}
+	if len(octets) >= 2 {
+		ipv4.OctetTwo = &ast.IntegerLiteral{
+			LiteralType: "Integer",
+			Value:       octets[1],
+		}
+	}
+	if len(octets) >= 3 {
+		ipv4.OctetThree = &ast.IntegerLiteral{
+			LiteralType: "Integer",
+			Value:       octets[2],
+		}
+	}
+	if len(octets) >= 4 {
+		ipv4.OctetFour = &ast.IntegerLiteral{
+			LiteralType: "Integer",
+			Value:       octets[3],
+		}
+	}
+
+	return ipv4
+}
+
 func (p *Parser) parseAlterServiceStatement() (ast.Statement, error) {
 	// Consume SERVICE
 	p.nextToken()