Method parse_message

compiler/fory_compiler/frontend/proto/parser.py:214–255

(self)

        )

    def parse_message(self) -> ProtoMessage:
        start = self.current()
        self.consume(TokenType.MESSAGE, "Expected 'message'")
        name = self.consume(TokenType.IDENT, "Expected message name").value
        self.consume(TokenType.LBRACE, "Expected '{' after message name")

        fields: List[ProtoField] = []
        nested_messages: List[ProtoMessage] = []
        nested_enums: List[ProtoEnum] = []
        oneofs = []
        options = {}

        while not self.check(TokenType.RBRACE):
            if self.check(TokenType.OPTION):
                opt_name, opt_value = self.parse_option_statement()
                options[opt_name] = opt_value
            elif self.check(TokenType.MESSAGE):
                nested_messages.append(self.parse_message())
            elif self.check(TokenType.ENUM):
                nested_enums.append(self.parse_enum())
            elif self.check(TokenType.RESERVED):
                self.parse_reserved()
            elif self.check(TokenType.EXTENSIONS):
                self.parse_extensions()
            elif self.check(TokenType.ONEOF):
                oneofs.append(self.parse_oneof())
            elif self.check(TokenType.SEMI):
                self.advance()
            else:
                fields.append(self.parse_field())

        self.consume(TokenType.RBRACE, "Expected '}' after message")
        return ProtoMessage(
            name=name,
            fields=fields,
            nested_messages=nested_messages,
            nested_enums=nested_enums,
            oneofs=oneofs,
            options=options,
            line=start.line,
            column=start.column,
        )

    def parse_oneof(self) -> ProtoOneof:
        start = self.current()