Implement lowering for OperatorName

purefunctor · Jun 20, 2024 · 59b0a5c · 59b0a5c
1 parent 2a52321
commit 59b0a5c
Show file tree

Hide file tree

Showing 6 changed files with 110 additions and 7 deletions.
diff --git a/crates/analyzer-surface/src/lower.rs b/crates/analyzer-surface/src/lower.rs
@@ -785,7 +785,7 @@ fn lower_expr(ctx: &mut Ctx, db: &dyn SurfaceDatabase, expr: Option<ast::Express
             ast::Expression::LambdaExpression(l) => lower_expr_lambda(ctx, db, l),
             ast::Expression::LetInExpression(l) => lower_expr_let_in(ctx, db, l),
             ast::Expression::LiteralExpression(l) => lower_expr_literal(ctx, db, l),
-            ast::Expression::OperatorNameExpression(_) => Expr::NotImplemented,
+            ast::Expression::OperatorNameExpression(o) => lower_expr_operator_name(db, o),
             ast::Expression::ParenthesizedExpression(p) => lower_expr_parenthesized(ctx, db, p),
             ast::Expression::RecordAccessExpression(_) => Expr::NotImplemented,
             ast::Expression::RecordUpdateExpression(_) => Expr::NotImplemented,
@@ -853,6 +853,8 @@ fn lower_expr_operator_chain(
     let tail = chain
         .tail()
         .filter_map(|pair| {
+            // dbg!(&pair);
+            // todo!();
             let name = lower_qualified_name(db, pair.operator()?.name());
             let expr = lower_expr(ctx, db, pair.term());
             Some((name, expr))
@@ -912,6 +914,10 @@ fn lower_expr_literal(
     }
 }
 
+fn lower_expr_operator_name(db: &dyn SurfaceDatabase, operator_name: &ast::OperatorNameExpression) -> Expr {
+    Expr::Variable(lower_qualified_name(db, operator_name.qualified_name()))
+}
+
 fn lower_expr_parenthesized(
     ctx: &mut Ctx,
     db: &dyn SurfaceDatabase,
@@ -1023,7 +1029,7 @@ fn lower_type(ctx: &mut Ctx, db: &dyn SurfaceDatabase, ty: Option<ast::Type>) ->
             ast::Type::ForallType(f) => lower_type_forall(ctx, db, f),
             ast::Type::IntegerType(_) => Type::NotImplemented,
             ast::Type::KindedType(_) => Type::NotImplemented,
-            ast::Type::OperatorNameType(_) => Type::NotImplemented,
+            ast::Type::OperatorNameType(o) => lower_type_operator_name(db, o),
             ast::Type::ParenthesizedType(p) => lower_type_parenthesized(ctx, db, p),
             ast::Type::RecordType(_) => Type::NotImplemented,
             ast::Type::RowType(_) => Type::NotImplemented,
@@ -1108,6 +1114,10 @@ fn lower_type_operator_chain(
     Type::OperatorChain(head, tail)
 }
 
+fn lower_type_operator_name(db: &dyn SurfaceDatabase, operator_name: &ast::OperatorNameType) -> Type {
+    Type::Constructor(lower_qualified_name(db, operator_name.qualified_name()))
+}
+
 fn lower_type_parenthesized(
     ctx: &mut Ctx,
     db: &dyn SurfaceDatabase,

diff --git a/crates/analyzer-surface/src/lower/inputs/operator-name.purs b/crates/analyzer-surface/src/lower/inputs/operator-name.purs
@@ -0,0 +1,5 @@
+module Main where
+
+expr = (+)
+
+ty :: (+)
diff --git a/...lyzer-surface/src/lower/snapshots/analyzer_surface__lower__tests__operator-name.purs.snap b/...lyzer-surface/src/lower/snapshots/analyzer_surface__lower__tests__operator-name.purs.snap
@@ -0,0 +1,81 @@
+---
+source: crates/analyzer-surface/src/lower/tests.rs
+expression: "(surface, expressions, let_names, binders, types)"
+---
+(
+    Module {
+        header: ModuleHeader {
+            name: ModuleName(
+                "Main",
+            ),
+            export_list: None,
+        },
+        imports: ModuleImports {
+            declarations: [],
+        },
+        body: ModuleBody {
+            declarations: [
+                ValueDeclaration(
+                    ValueDeclaration {
+                        id: Idx::<ValueGroup>(0),
+                        name: Name(
+                            "expr",
+                        ),
+                        annotation: None,
+                        equations: [
+                            ValueEquation {
+                                binders: [],
+                                binding: Unconditional {
+                                    where_expr: WhereExpr {
+                                        expr_id: Idx::<Expr>(0),
+                                        let_bindings: [],
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ),
+                ValueDeclaration(
+                    ValueDeclaration {
+                        id: Idx::<ValueGroup>(1),
+                        name: Name(
+                            "ty",
+                        ),
+                        annotation: Some(
+                            Idx::<Type>(0),
+                        ),
+                        equations: [],
+                    },
+                ),
+            ],
+            class_declarations: {},
+            data_declarations: {},
+            value_declarations: {
+                Idx::<ValueGroup>(0): 0,
+                Idx::<ValueGroup>(1): 1,
+            },
+        },
+    },
+    [
+        Variable(
+            Qualified {
+                prefix: None,
+                value: Name(
+                    "+",
+                ),
+            },
+        ),
+    ],
+    [],
+    [],
+    [
+        Constructor(
+            Qualified {
+                prefix: None,
+                value: Name(
+                    "+",
+                ),
+            },
+        ),
+    ],
+)
diff --git a/crates/parsing/src/grammar/rules.rs b/crates/parsing/src/grammar/rules.rs
@@ -602,23 +602,18 @@ fn expr_atom(parser: &mut Parser) {
             name_end(parser, SyntaxKind::VariableExpression);
         }
         SyntaxKind::LeftParenthesis => {
-            let mut wrapped = parser.start();
             parser.expect(SyntaxKind::LeftParenthesis);
-
             if parser.current().is_operator() {
                 name_ref(parser, SyntaxKind::Operator);
                 parser.expect(SyntaxKind::RightParenthesis);
-                wrapped.end(parser, SyntaxKind::Wrapped);
                 name_end(parser, SyntaxKind::OperatorNameExpression);
             } else if has_prefix {
                 parser.error_recover("expected an operator");
                 parser.expect(SyntaxKind::RightParenthesis);
-                wrapped.end(parser, SyntaxKind::Wrapped);
                 name_end(parser, SyntaxKind::OperatorNameExpression);
             } else {
                 expr_0(parser);
                 parser.expect(SyntaxKind::RightParenthesis);
-                wrapped.cancel(parser);
                 qualified.cancel(parser);
                 expression.end(parser, SyntaxKind::ParenthesizedExpression);
             };

diff --git a/crates/syntax/src/ast/expression.rs b/crates/syntax/src/ast/expression.rs
@@ -141,6 +141,12 @@ impl RecordPun {
     }
 }
 
+impl OperatorNameExpression {
+    pub fn qualified_name(&self) -> Option<QualifiedName> {
+        support::child(&self.node)
+    }
+}
+
 impl ParenthesizedExpression {
     pub fn expression(&self) -> Option<Expression> {
         support::child(&self.node)

diff --git a/crates/syntax/src/ast/ty.rs b/crates/syntax/src/ast/ty.rs
@@ -105,6 +105,12 @@ impl ForallType {
 
 _has_children!(ForallVariables<TypeVariableBinding>);
 
+impl OperatorNameType {
+    pub fn qualified_name(&self) -> Option<QualifiedName> {
+        support::child(&self.node)
+    }
+}
+
 impl ParenthesizedType {
     pub fn ty(&self) -> Option<Type> {
         Type::cast(self.node.first_child()?)