fix: remove unused op statement

gen/midas.py

@@ -48,12 +48,6 @@ class ExtendStmt:
     members: list[MemberStmt]
 
 
-class OpStmt:
-    name: Token
-    operand: Type
-    result: Type
-
-
 class PredicateStmt:
     name: Token
     subject: Token

midas/ast/midas.py

@@ -49,9 +49,6 @@ class Stmt(ABC):
         @abstractmethod
         def visit_extend_stmt(self, stmt: ExtendStmt) -> T: ...
 
-        @abstractmethod
-        def visit_op_stmt(self, stmt: OpStmt) -> T: ...
-
         @abstractmethod
         def visit_predicate_stmt(self, stmt: PredicateStmt) -> T: ...
 
@@ -86,16 +83,6 @@ class ExtendStmt(Stmt):
         return visitor.visit_extend_stmt(self)
 
 
-@dataclass(frozen=True)
-class OpStmt(Stmt):
-    name: Token
-    operand: Type
-    result: Type
-
-    def accept(self, visitor: Stmt.Visitor[T]) -> T:
-        return visitor.visit_op_stmt(self)
-
-
 @dataclass(frozen=True)
 class PredicateStmt(Stmt):
     name: Token

midas/ast/printer.py

@@ -146,19 +146,6 @@ class MidasAstPrinter(
                         self._mark_last()
                     member.accept(self)
 
-    def visit_op_stmt(self, stmt: m.OpStmt) -> None:
-        self._write_line("OpStmt")
-        with self._child_level():
-            self._write_line(f'name: "{stmt.name.lexeme}"')
-
-            self._write_line("operand")
-            with self._child_level(single=True):
-                stmt.operand.accept(self)
-
-            self._write_line("result", last=True)
-            with self._child_level(single=True):
-                stmt.result.accept(self)
-
     def visit_predicate_stmt(self, stmt: m.PredicateStmt):
         self._write_line("PredicateStmt")
         with self._child_level():
@@ -378,11 +365,6 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
         res += self.indented("}")
         return res
 
-    def visit_op_stmt(self, stmt: m.OpStmt):
-        operand: str = stmt.operand.accept(self)
-        result: str = stmt.result.accept(self)
-        return self.indented(f"op {stmt.name.lexeme}({operand}) -> {result}\n")
-
     def visit_predicate_stmt(self, stmt: m.PredicateStmt):
         name: str = stmt.name.lexeme
         subject: str = stmt.subject.lexeme

midas/checker/midas.py

@@ -105,8 +105,6 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type
                 member.kind == m.MemberKind.METHOD,
             )
 
-    def visit_op_stmt(self, stmt: m.OpStmt) -> None: ...
-
     def visit_predicate_stmt(self, stmt: m.PredicateStmt) -> None: ...
 
     def visit_logical_expr(self, expr: m.LogicalExpr) -> None: ...

midas/cli/highlighter.py

@@ -241,12 +241,6 @@ class MidasHighlighter(
         for member in stmt.members:
             member.accept(self)
 
-    def visit_op_stmt(self, stmt: m.OpStmt) -> None:
-        self.wrap(stmt, "op")
-        self.wrap(LocatableToken(stmt.name), "op-name")
-        stmt.operand.accept(self)
-        stmt.result.accept(self)
-
     def visit_predicate_stmt(self, stmt: m.PredicateStmt) -> None:
         self.wrap(stmt, "predicate")
         self.wrap(LocatableToken(stmt.name), "predicate-name")
@@ -302,7 +296,7 @@ class MidasHighlighter(
 
     def visit_function_type(self, type: m.FunctionType) -> None:
         self.wrap(type, "function")
-        for arg in type.pos_args + type.kw_args:
+        for arg in type.pos_args + type.args + type.kw_args:
             arg.type.accept(self)
         type.returns.accept(self)
 

midas/lexer/token.py

@@ -46,7 +46,6 @@ class TokenType(Enum):
 
     # Keywords
     TYPE = auto()
-    OP = auto()
     PREDICATE = auto()
     EXTEND = auto()
     WHERE = auto()
@@ -63,7 +62,6 @@ class TokenType(Enum):
 
 KEYWORDS: dict[str, TokenType] = {
     "type": TokenType.TYPE,
-    "op": TokenType.OP,
     "predicate": TokenType.PREDICATE,
     "extend": TokenType.EXTEND,
     "where": TokenType.WHERE,

midas/parser/midas.py

@@ -17,7 +17,6 @@ from midas.ast.midas import (
     MemberKind,
     MemberStmt,
     NamedType,
-    OpStmt,
     PredicateStmt,
     Stmt,
     Type,
@@ -37,9 +36,10 @@ class MidasParser(Parser):
 
     SYNC_BOUNDARY: set[TokenType] = {
         TokenType.TYPE,
-        TokenType.OP,
         TokenType.EXTEND,
         TokenType.PREDICATE,
+        TokenType.PROP,
+        TokenType.FUNC,
     }
 
     def parse(self) -> list[Stmt]:
@@ -444,31 +444,6 @@ class MidasParser(Parser):
             members=members,
         )
 
-    def op_declaration(self) -> OpStmt:
-        """Parse an operation definition
-
-        An operation is written `op name(Type) -> Type`
-
-        Returns:
-            OpStmt: the parsed operation statement
-        """
-        keyword: Token = self.consume(TokenType.OP, "Expected 'op' keyword")
-
-        name: Token = self.consume(TokenType.IDENTIFIER, "Expected operation name")
-        self.consume(TokenType.LEFT_PAREN, "Expected '(' before operand type")
-        operand: Type = self.type_expr()
-        self.consume(TokenType.RIGHT_PAREN, "Expected ')' after operand type")
-
-        self.consume(TokenType.ARROW, "Expected '->' before result type")
-        result: Type = self.type_expr()
-
-        return OpStmt(
-            location=keyword.location_to(self.previous()),
-            name=name,
-            operand=operand,
-            result=result,
-        )
-
     def predicate_declaration(self) -> PredicateStmt:
         """Parse a predicate declaration
 

tests/serializer/midas.py

@@ -15,7 +15,6 @@ from midas.ast.midas import (
     LogicalExpr,
     MemberStmt,
     NamedType,
-    OpStmt,
     PredicateStmt,
     Stmt,
     Type,
@@ -75,14 +74,6 @@ class MidasAstJsonSerializer(
             "members": self._serialize_list(stmt.members),
         }
 
-    def visit_op_stmt(self, stmt: OpStmt) -> dict:
-        return {
-            "_type": "OpStmt",
-            "name": stmt.name.lexeme,
-            "operand": stmt.operand.accept(self),
-            "result": stmt.result.accept(self),
-        }
-
     def visit_predicate_stmt(self, stmt: PredicateStmt) -> dict:
         return {
             "_type": "PredicateStmt",