schala-lang/language/src/reduced_ir/mod.rs

@@ -136,28 +136,7 @@ impl<'a> Reducer<'a> {
                     body: self.function_internal_block(body),
                 })
             },
-            NamedStruct { name, fields } => {
+            NamedStruct { .. } => Expression::ReductionError("NamedStruct not implemented".to_string()), //self.reduce_named_struct(name, fields),
-                let symbol = self.symbol_table.lookup_symbol(&name.id).unwrap();
-                let constructor = match symbol.spec() {
-                    SymbolSpec::RecordConstructor { index, members: _, type_id } => Expression::Callable(Callable::RecordConstructor {
-                        type_id,
-                        tag: index as u32,
-                    }),
-                    e => return Expression::ReductionError(format!("Bad symbol for NamedStruct: {:?}", e)),
-                };
-
-                //TODO need to order the fields correctly, which needs symbol table information
-                // Until this happens, NamedStructs won't work
-                let mut ordered_args = vec![];
-                for (_name, _type_id) in fields {
-                    unimplemented!()
-                }
-
-                Expression::Call {
-                    f: Box::new(constructor),
-                    args: ordered_args,
-                }
-            },
             Index { .. } => Expression::ReductionError("Index expr not implemented".to_string()),
             WhileExpression { .. } => Expression::ReductionError("While expr not implemented".to_string()),
             ForExpression { .. } => Expression::ReductionError("For expr not implemented".to_string()),
@@ -377,13 +356,199 @@ impl ast::Pattern {
                     spec => return Err(format!("Unexpected VarOrName symbol: {:?}", spec).into())
                 }
             },
-            ast::Pattern::Record(name, _specified_members/*Vec<(Rc<String>, Pattern)>*/) => {
+            ast::Pattern::Record(_name, _members/*Vec<(Rc<String>, Pattern)>*/) => {
-                let symbol = symbol_table.lookup_symbol(&name.id).unwrap();
+                unimplemented!()
-                match symbol.spec() {
+            },
-                    SymbolSpec::RecordConstructor { index: _, members: _, type_id: _ } => unimplemented!(),
-                    spec => return Err(format!("Unexpected Record pattern symbol: {:?}", spec).into())
-                }
-            }
         })
     }
 }
+
+/*
+impl ast::Pattern {
+    fn to_subpattern(&self, symbol_table: &SymbolTable) -> Subpattern {
+        use ast::Pattern::*;
+        use Expression::ReductionError;
+
+        match self {
+            Ignored => Subpattern {
+                tag: None,
+                subpatterns: vec![],
+                guard: None,
+            },
+            Literal(lit) => lit.to_subpattern(symbol_table),
+            /*
+            TupleStruct(QualifiedName { components, id }, inner_patterns) => {
+                match symbol_table.lookup_symbol(id) {
+                    Some(symbol) => handle_symbol(Some(symbol), inner_patterns, symbol_table),
+                    None => panic!("Symbol {:?} not found", components),
+                }
+            }
+            */
+            _ => Subpattern {
+                tag: None,
+                subpatterns: vec![],
+                guard: None,
+            }
+        }
+            /*
+            TuplePattern(inner_patterns) => handle_symbol(None, inner_patterns, symbol_table),
+            Record(_name, _pairs) => {
+                unimplemented!()
+            }
+            VarOrName(QualifiedName { components, id }) => {
+                // if symbol is Some, treat this as a symbol pattern. If it's None, treat it
+                // as a variable.
+                match symbol_table.lookup_symbol(id) {
+                    Some(symbol) => handle_symbol(Some(symbol), &[], symbol_table),
+                    None => {
+                        println!("Components: {:?}", components);
+                        let name = if components.len() == 1 {
+                            components[0].clone()
+                        } else {
+                            panic!("check this line of code yo");
+                        };
+                        Subpattern {
+                            tag: None,
+                            subpatterns: vec![],
+                            guard: None,
+                            bound_vars: vec![Some(name)],
+                        }
+                    }
+                }
+            }
+            */
+    }
+}
+*/
+
+/*
+fn handle_symbol(
+    symbol: Option<&Symbol>,
+    inner_patterns: &[Pattern],
+    symbol_table: &SymbolTable,
+) -> Subpattern {
+    use ast::Pattern::*;
+
+    let tag = symbol.map(|symbol| match symbol.spec {
+        SymbolSpec::DataConstructor { index, .. } => index,
+        _ => {
+            panic!("Symbol is not a data constructor - this should've been caught in type-checking")
+        }
+    });
+    let bound_vars = inner_patterns
+        .iter()
+        .map(|p| match p {
+            VarOrName(qualified_name) => {
+                let symbol_exists = symbol_table.lookup_symbol(&qualified_name.id).is_some();
+                if symbol_exists {
+                    None
+                } else {
+                    let QualifiedName { components, .. } = qualified_name;
+                    if components.len() == 1 {
+                        Some(components[0].clone())
+                    } else {
+                        panic!("Bad variable name in pattern");
+                    }
+                }
+            }
+            _ => None,
+        })
+        .collect();
+
+    let subpatterns = inner_patterns
+        .iter()
+        .map(|p| match p {
+            Ignored => None,
+            VarOrName(_) => None,
+            Literal(other) => Some(other.to_subpattern(symbol_table)),
+            tp @ TuplePattern(_) => Some(tp.to_subpattern(symbol_table)),
+            ts @ TupleStruct(_, _) => Some(ts.to_subpattern(symbol_table)),
+            Record(..) => unimplemented!(),
+        })
+        .collect();
+
+    let guard = None;
+    /*
+    let guard_equality_exprs: Vec<Expr> = subpatterns.iter().map(|p| match p {
+    Literal(lit) => match lit {
+    _ => unimplemented!()
+    },
+    _ => unimplemented!()
+    }).collect();
+    */
+
+    Subpattern {
+        tag,
+        subpatterns,
+        guard,
+        bound_vars,
+    }
+}
+*/
+
+/*
+impl ast::PatternLiteral {
+    fn to_subpattern(&self, _symbol_table: &SymbolTable) -> Subpattern {
+        use ast::PatternLiteral::*;
+
+        match self {
+            NumPattern { neg, num } => {
+                let comparison = Expression::Literal(match (neg, num) {
+                    (false, ast::ExpressionKind::NatLiteral(n)) => Literal::Nat(*n),
+                    (false, ast::ExpressionKind::FloatLiteral(f)) => Literal::Float(*f),
+                    (true, ast::ExpressionKind::NatLiteral(n)) => Literal::Int(-(*n as i64)),
+                    (true, ast::ExpressionKind::FloatLiteral(f)) => Literal::Float(-f),
+                    _ => panic!("This should never happen"),
+                });
+                unimplemented!()
+                /*
+                let guard = Some(Expr::Call {
+                    f: Box::new(Expr::Func(Func::BuiltIn(Builtin::Equality))),
+                    args: vec![comparison, Expr::ConditionalTargetSigilValue],
+                });
+                Subpattern {
+                    tag: None,
+                    subpatterns: vec![],
+                    guard,
+                }
+                */
+            }
+            _ => unimplemented!()
+            /*
+            StringPattern(s) => {
+                let guard = Some(Expr::Call {
+                    f: Box::new(Expr::Func(Func::BuiltIn(Builtin::Equality))),
+                    args: vec![
+                        Expr::Lit(Lit::StringLit(s.clone())),
+                        Expr::ConditionalTargetSigilValue,
+                    ],
+                });
+
+                Subpattern {
+                    tag: None,
+                    subpatterns: vec![],
+                    guard,
+                    bound_vars: vec![],
+                }
+            }
+            BoolPattern(b) => {
+                let guard = Some(if *b {
+                    Expr::ConditionalTargetSigilValue
+                } else {
+                    Expr::Call {
+                        f: Box::new(Expr::Func(Func::BuiltIn(Builtin::BooleanNot))),
+                        args: vec![Expr::ConditionalTargetSigilValue],
+                    }
+                });
+                Subpattern {
+                    tag: None,
+                    subpatterns: vec![],
+                    guard,
+                    bound_vars: vec![],
+                }
+            }
+            */
+        }
+    }
+}
+*/

schala-lang/language/src/reduced_ir/types.rs

@@ -98,10 +98,6 @@ pub enum Callable {
         arity: u32,
         tag: u32
     },
-    RecordConstructor {
-        type_id: TypeId,
-        tag: u32,
-    },
 }
 
 #[derive(Debug, Clone)]

schala-lang/language/src/tree_walk_eval/mod.rs

@@ -358,9 +358,6 @@ impl<'a> State<'a> {
                   items: evaluated_args
               })
           }
-          Callable::RecordConstructor { type_id: _, tag: _ } => {
-              unimplemented!()
-          }
       }
   }