Move classes implementation outside of parser module

Author: aNNiMON

ownlang-core/src/main/java/com/annimon/ownlang/exceptions/UnknownClassException.java

@@ -6,11 +6,6 @@ public final class UnknownClassException extends OwnLangRuntimeException {
 
     private final String className;
 
-    public UnknownClassException(String name) {
-        super("Unknown class " + name);
-        this.className = name;
-    }
-
     public UnknownClassException(String name, Range range) {
         super("Unknown class " + name, range);
         this.className = name;

ownlang-core/src/main/java/com/annimon/ownlang/lib/ClassDeclaration.java

@@ -0,0 +1,24 @@
+package com.annimon.ownlang.lib;
+
+import java.util.List;
+
+public record ClassDeclaration(
+        String name,
+        List<ClassField> classFields,
+        List<ClassMethod> classMethods) implements Instantiable {
+
+    /**
+     * Create an instance and put evaluated fields with method declarations
+     * @return new {@link ClassInstance}
+     */
+    public ClassInstance newInstance(Value[] args) {
+        final var instance = new ClassInstance(name);
+        for (ClassField f : classFields) {
+            instance.addField(f);
+        }
+        for (ClassMethod m : classMethods) {
+            instance.addMethod(m);
+        }
+        return instance.callConstructor(args);
+    }
+}

ownlang-core/src/main/java/com/annimon/ownlang/lib/ClassField.java

@@ -0,0 +1,7 @@
+package com.annimon.ownlang.lib;
+
+public record ClassField(
+        String name,
+        EvaluableValue evaluableValue
+) {
+}

ownlang-parser/src/main/java/com/annimon/ownlang/lib/ClassInstanceValue.java renamed to ownlang-core/src/main/java/com/annimon/ownlang/lib/ClassInstance.java

@@ -1,16 +1,18 @@
 package com.annimon.ownlang.lib;
 
+import com.annimon.ownlang.exceptions.OwnLangRuntimeException;
 import com.annimon.ownlang.exceptions.TypeException;
 import java.util.Objects;
 
-public class ClassInstanceValue implements Value {
-    
+public class ClassInstance implements Value {
+
     private final String className;
     private final MapValue thisMap;
     private ClassMethod constructor;
-    private UserDefinedFunction toString;
+    private ClassMethod toString;
+    private boolean isInstantiated;
 
-    public ClassInstanceValue(String name) {
+    public ClassInstance(String name) {
         this.className = name;
         thisMap = new MapValue(10);
     }
@@ -19,31 +21,33 @@ public MapValue getThisMap() {
         return thisMap;
     }
 
-    public String getClassName() {
-        return className;
-    }
-
-    public void addField(String name, Value value) {
-        thisMap.set(name, value);
+    public void addField(ClassField f) {
+        thisMap.set(f.name(), f.evaluableValue().eval());
     }
 
-    public void addMethod(String name, ClassMethod method) {
-        if (name.equals("toString")) {
-            toString = method;
-        }
+    public void addMethod(ClassMethod method) {
+        method.setClassInstance(this);
+        final String name = method.getName();
         thisMap.set(name, method);
         if (name.equals(className)) {
             constructor = method;
+        } else if (name.equals("toString")) {
+            toString = method;
         }
     }
 
-
-    public void callConstructor(Value[] args) {
+    public ClassInstance callConstructor(Value[] args) {
+        if (isInstantiated) {
+            throw new OwnLangRuntimeException(
+                    "Class %s was already instantiated".formatted(className));
+        }
         if (constructor != null) {
             CallStack.enter("class " + className, constructor, null);
             constructor.execute(args);
             CallStack.exit();
         }
+        isInstantiated = true;
+        return this;
     }
 
     public Value access(Value value) {
@@ -53,15 +57,16 @@ public Value access(Value value) {
     public void set(Value key, Value value) {
         final Value v = thisMap.get(key);
         if (v == null) {
-            throw new RuntimeException("Unable to add new field "
-                    + key.asString() + " to class " + className);
+            throw new OwnLangRuntimeException(
+                    "Unable to add new field %s to class %s"
+                            .formatted(key.asString(), className));
         }
         thisMap.set(key, value);
     }
 
     @Override
     public Object raw() {
-        return null;
+        return thisMap;
     }
 
     @Override
@@ -77,9 +82,9 @@ public double asNumber() {
     @Override
     public String asString() {
         if (toString != null) {
-            return toString.execute(new Value[0]).asString();
+            return toString.execute().asString();
         }
-        return className + "@" + thisMap;
+        return className + "@" + thisMap.asString();
     }
 
     @Override
@@ -100,7 +105,7 @@ public boolean equals(Object obj) {
         if (obj == null) return false;
         if (getClass() != obj.getClass())
             return false;
-        final ClassInstanceValue other = (ClassInstanceValue) obj;
+        final ClassInstance other = (ClassInstance) obj;
         return Objects.equals(this.className, other.className)
                 && Objects.equals(this.thisMap, other.thisMap);
     }

ownlang-core/src/main/java/com/annimon/ownlang/lib/ClassMethod.java

@@ -0,0 +1,60 @@
+package com.annimon.ownlang.lib;
+
+import java.util.Objects;
+
+public class ClassMethod implements Function {
+    private final String name;
+    private final Function function;
+    private ClassInstance classInstance;
+
+    public ClassMethod(String name, Function function) {
+        this.name = name;
+        this.function = function;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setClassInstance(ClassInstance classInstance) {
+        this.classInstance = classInstance;
+    }
+
+    @Override
+    public Value execute(Value... args) {
+        ScopeHandler.push();
+        ScopeHandler.defineVariableInCurrentScope("this", classInstance.getThisMap());
+
+        try {
+            return function.execute(args);
+        } finally {
+            ScopeHandler.pop();
+        }
+    }
+
+    @Override
+    public int getArgsCount() {
+        return function.getArgsCount();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (ClassMethod) obj;
+        return Objects.equals(this.name, that.name) &&
+                Objects.equals(this.function, that.function);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, function);
+    }
+
+    @Override
+    public String toString() {
+        return "ClassMethod[" +
+                "name=" + name + ", " +
+                "function=" + function + ']';
+    }
+}

ownlang-core/src/main/java/com/annimon/ownlang/lib/EvaluableValue.java

@@ -0,0 +1,6 @@
+package com.annimon.ownlang.lib;
+
+public interface EvaluableValue {
+
+    Value eval();
+}

ownlang-core/src/main/java/com/annimon/ownlang/lib/RootScope.java

@@ -8,11 +8,13 @@
 final class RootScope extends Scope {
     private final Map<String, Value> constants;
     private final Map<String, Function> functions;
+    private final Map<String, ClassDeclaration> classDeclarations;
     private final Set<String> loadedModules;
 
     RootScope() {
         functions = new ConcurrentHashMap<>();
         constants = new ConcurrentHashMap<>();
+        classDeclarations = new ConcurrentHashMap<>();
         constants.put("true", NumberValue.ONE);
         constants.put("false", NumberValue.ZERO);
         loadedModules = new CopyOnWriteArraySet<>();
@@ -71,6 +73,18 @@ public Map<String, Function> getFunctions() {
     }
 
 
+    public ClassDeclaration getClassDeclaration(String name) {
+        return classDeclarations.get(name);
+    }
+
+    public void setClassDeclaration(ClassDeclaration classDeclaration) {
+        classDeclarations.put(classDeclaration.name(), classDeclaration);
+    }
+
+    public Map<String, ClassDeclaration> getClassDeclarations() {
+        return classDeclarations;
+    }
+
     public Set<String> getLoadedModules() {
         return loadedModules;
     }

ownlang-core/src/main/java/com/annimon/ownlang/lib/ScopeHandler.java

@@ -28,6 +28,11 @@ public static Map<String, Function> functions() {
         return rootScope.getFunctions();
     }
 
+    public static Map<String, ClassDeclaration> classDeclarations() {
+        return rootScope.getClassDeclarations();
+    }
+
+
     static RootScope rootScope() {
         return rootScope;
     }
@@ -75,6 +80,15 @@ public static void setFunction(String name, Function function) {
     }
 
 
+    public static ClassDeclaration getClassDeclaration(String name) {
+        return rootScope.getClassDeclaration(name);
+    }
+
+    public static void setClassDeclaration(ClassDeclaration classDeclaration) {
+        rootScope.setClassDeclaration(classDeclaration);
+    }
+
+
     public static boolean isVariableOrConstantExists(String name) {
         if (rootScope().containsConstant(name)) {
             return true;