Add extending to classes

extensions/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "modu-lang",
   "displayName": "Modu Lang",
   "description": "Syntax highlightning for the Modu Programming Language",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cyteon/modu"
@@ -20,7 +20,7 @@
   ],
   "scripts": {
     "test-vscode": "vscode-test",
-    "install": "vsce package && code --install-extension ./modu-lang-1.9.0.vsix",
+    "install": "vsce package && code --install-extension ./modu-lang-1.10.0.vsix",
     "vsce": "vsce package",
     "test": "npm run vsce && npm run install"
   },

extensions/vscode/syntaxes/modu.tmLanguage.json

@@ -19,7 +19,7 @@
 		"keywords": {
 			"patterns": [{
 				"name": "keyword.control.modu",
-				"match": "\\b(if|else|fn|let|const|import|as|return|loop|break|continue|for|while|and|or|in|not in|class|self|try|catch)\\b"
+				"match": "\\b(if|else|fn|let|const|import|as|return|loop|break|continue|for|while|and|or|in|not in|class|self|try|catch|extends|super)\\b"
 			}]
 		},
 

extensions/zed/extension.toml

@@ -8,4 +8,4 @@ repository = "https://github.com/cyteon/modu"
 
 [grammars.modu]
 repository = "https://github.com/cyteon/tree-sitter-modu"
-rev = "e84f411c28e4792066dc3bf19015c48d9adc5e1a"
+rev = "a320fb973d93ac5024ad0a9c608b92634603b4d3"

extensions/zed/languages/modu/highlights.scm

@@ -16,11 +16,14 @@
   "or"
   "try"
   "catch"
+  "extends"
 ] @keyword
 
+(self) @variable.special
+(super) @variable.special
+
 (boolean) @constant.builtin
 (null) @constant.builtin
-(self) @variable.special
 (string) @string
 (number) @number
 (comment) @comment

lang/examples/oop.modu

@@ -33,4 +33,31 @@ print(counter.get());
 
 counter.reset();
 counter.decrement();
-print(counter.value);
+print(counter.value);
+
+print("\n---\n");
+
+class xCounter extends Counter {
+    fn init(start, mult) {
+        super.init(start);
+        print(super.init);
+
+        self.mult = mult;
+    }
+
+    fn mul() {
+        self.value *= self.mult;
+    }
+
+    fn div() {
+        self.value /= self.mult;
+    }
+}
+
+let xc = xCounter(8, 2);
+print(xc.value);
+
+xc.mul();
+xc.increment();
+
+print(xc.value);

lang/src/ast.rs

@@ -25,6 +25,7 @@ pub enum Expr {
     Identifier(String),
     Bool(bool),
     Return(Box<Spanned<Expr>>),
+
     Null,
     Break,
     Continue,
@@ -139,6 +140,7 @@ pub enum Expr {
     Class {
         name: String,
         methods: Vec<Spanned<Expr>>,
+        parent: Option<String>,
     },
 
     Try {

lang/src/cli/repl.rs

@@ -22,7 +22,7 @@ pub struct Syntax {
 impl Syntax {
     pub fn new() -> Self {
         Self {
-            keyword_re: Regex::new(r"\b(if|else|fn|let|const|import|as|return|loop|break|continue|for|while|and|or|in|not in|class|self|try|catch)\b").unwrap(),
+            keyword_re: Regex::new(r"\b(if|else|fn|let|const|import|as|return|loop|break|continue|for|while|and|or|in|not in|class|self|try|catch|extends|super)\b").unwrap(),
             string_re: Regex::new(r#""([^"\\]|\\.)*"|'([^'\\]|\\.)*'"#).unwrap(),
             comment_re: Regex::new(r"//.*$|/\*.*?\*/").unwrap(),
             number_re: Regex::new(r"\b\d(?:_?\d)*\b").unwrap(),

lang/src/compiler/compiler.rs

@@ -214,10 +214,14 @@ impl Compiler {
                 if let Expr::PropertyAccess { object, property: _ } = &callee.node {
                     let (target_local, target_global) = match &object.node {
                         Expr::Identifier(name) => {
-                            match self.scope.resolve(name) {
-                                Variable::Local(index) => (Some(index), None),
-                                Variable::Global(_) => (None, Some(name.to_string())),
-                            }
+                            if name == "super" {
+                                (Some(0), None)
+                            } else {
+                                match self.scope.resolve(name) {
+                                    Variable::Local(index) => (Some(index), None),
+                                    Variable::Global(_) => (None, Some(name.to_string())),
+                                }
+                            } 
                         }
 
                         _ => (None, None),
@@ -230,11 +234,15 @@ impl Compiler {
             }
 
             Expr::PropertyAccess { object, property } => {
-                self.compile_expr(*object.clone())?;
-                self.emit(Instruction::GetProperty(property.clone()), span);
+                if matches!(&object.node, Expr::Identifier(n) if n == "super") {
+                    self.emit(Instruction::LoadLocal(0), span);
+                    self.emit(Instruction::GetSuper(property.clone()), span);
+                } else {
+                    self.compile_expr(*object.clone())?;
+                    self.emit(Instruction::GetProperty(property.clone()), span);
+                }
             }
 
-
             Expr::IndexAccess { object, index } => {
                 self.compile_expr(*object.clone())?;
                 self.compile_expr(*index.clone())?;
@@ -655,7 +663,7 @@ impl Compiler {
                 self.emit(Instruction::Import { path: name.clone(), alias: alias.clone() }, span);
             }
 
-            Expr::Class { name, methods } => {
+            Expr::Class { name, methods, parent } => {
                 let mut methods_map = HashMap::new();
 
                 for f in methods {
@@ -696,10 +704,19 @@ impl Compiler {
                     }
                 }
 
-                let class_value = Value::Class { name: name.clone(), methods: methods_map };
+                let class_value = Value::Class { name: name.clone(), methods: methods_map, parent_methods: HashMap::new() };
                 let index = self.add_constant(class_value);
-
                 self.emit(Instruction::Push(index), span);
+
+                if let Some(name) = parent {
+                    match self.scope.resolve(&name) {
+                        Variable::Local(index) => self.emit(Instruction::LoadLocal(index), span),
+                        Variable::Global(name) => self.emit(Instruction::LoadGlobal(name), span),
+                    }
+
+                    self.emit(Instruction::Extend, span);
+                }
+
                 self.store_variable(name, span);
             }
 

lang/src/lexer.rs

@@ -98,6 +98,12 @@ pub enum Token {
     #[token("class")]
     Class,
 
+    #[token("extends")]
+    Extends,
+
+    #[token("super")]
+    Super,
+
     #[token("import")]
     Import,
 

lang/src/parser.rs

@@ -35,6 +35,8 @@ fn parser<'src>() -> impl Parser<
             (Token::String(name), span) => SpannedExpr { node: Expr::String(name), span },
             (Token::Identifier(name), span) => SpannedExpr { node: Expr::Identifier(name), span },
             (Token::Bool(b), span) => SpannedExpr { node: Expr::Bool(b), span },
+            (Token::Super, span) => SpannedExpr { node: Expr::Identifier("super".to_string()), span },
+
             (Token::Null, span) => SpannedExpr { node: Expr::Null, span },
             (Token::Break, span) => SpannedExpr { node: Expr::Break, span },
             (Token::Continue, span) => SpannedExpr { node: Expr::Continue, span },
@@ -436,13 +438,20 @@ fn parser<'src>() -> impl Parser<
 
         let class_stmt = select! { (Token::Class, span) => span }
             .then(select! { (Token::Identifier(name), _) => name }.labelled("class name"))
+            .then(
+                select! { (Token::Extends, _) }
+                .ignore_then(
+                    select! { (Token::Identifier(name), _) => name }
+                )
+                .or_not()
+            )
             .then(
                 select! { (Token::LBrace, span) => span }
                     .then(fn_stmt.clone().repeated().collect::<Vec<_>>())
                     .then(select! { (Token::RBrace, span) => span })
             )
-            .map(|((start, name), ((_lbrace, methods), end)): ((Span, String), ((Span, Vec<SpannedExpr>), Span))| SpannedExpr {
-                node: Expr::Class { name, methods },
+            .map(|(((start, name), parent), ((_lbrace, methods), end)): (((Span, String), Option<String>), ((Span, Vec<SpannedExpr>), Span))| SpannedExpr {
+                node: Expr::Class { name, methods, parent },
                 span: Span::from(start.start..end.end),
             })
             .labelled("class declaration");

lang/src/vm/instruction.rs

@@ -31,6 +31,9 @@ pub enum Instruction {
     MakeObject(usize),
     MakeRange { inclusive: bool },
 
+    Extend,
+    GetSuper(String),
+
     GetProperty(String),
     SetProperty(String),
     IndexGet,

lang/src/vm/value.rs

@@ -27,11 +27,13 @@ pub enum Value {
     Class {
         name: String,
         methods: HashMap<String, Value>,
+        parent_methods: HashMap<String, Value>,
     },
 
     Instance {
         class_name: String,
         properties: HashMap<String, Value>,
+        parent_methods: HashMap<String, Value>,
     },
 
     InstanceFn {
@@ -94,11 +96,15 @@ impl PartialEq for Value {
             (Value::Function { chunk_id: a_id, arity: a_arity }, Value::Function { chunk_id: b_id, arity: b_arity }) => a_id == b_id && a_arity == b_arity,
             (Value::NativeFn(a), Value::NativeFn(b)) => a.name == b.name,
             (Value::BuiltinFn(a), Value::BuiltinFn(b)) => a.name == b.name,
-            (Value::Class { name: a_name, methods: a_methods }, Value::Class { name: b_name, methods: b_methods }) => a_name == b_name && a_methods == b_methods,
 
             (
-                Value::Instance { class_name: a_class, properties: a_props },
-                Value::Instance { class_name: b_class, properties: b_props }
+                Value::Class { name: a_name, methods: a_methods, .. },
+                Value::Class { name: b_name, methods: b_methods, .. }
+            ) => a_name == b_name && a_methods == b_methods,
+
+            (
+                Value::Instance { class_name: a_class, properties: a_props, .. },
+                Value::Instance { class_name: b_class, properties: b_props, .. }
             ) => a_class == b_class && a_props == b_props,
 
             (