Begin work on background compiling.

Author: Moderocky

src/main/java/org/byteskript/skript/compiler/Context.java

@@ -169,6 +169,15 @@ public void destroySection() {
         }
     }
 
+    public void destroySections() {
+        for (final SectionMeta section : sections) {
+            for (final Section handler : section.getHandlers()) {
+                handler.onSectionExit(this, section);
+            }
+        }
+        this.sections.clear();
+    }
+    
     public abstract boolean hasFunction(String name, int arguments);
 
     public Function getDefaultFunction(String name, int arguments) {
@@ -202,6 +211,10 @@ public void destroyUnit() {
         units.remove(0);
     }
 
+    public void destroyUnits() {
+        units.clear();
+    }
+    
     public void createUnit(final LanguageElement element) {
         units.add(0, new Unit(element));
     }

src/main/java/org/byteskript/skript/compiler/Pattern.java

@@ -212,6 +212,10 @@ public Type[] expected() {
             return expected;
         }
 
+        public boolean equals(String string) {
+            return matcher.group().equals(string);
+        }
+        
     }
 
 }

src/main/java/org/byteskript/skript/compiler/SimpleSkriptCompiler.java

@@ -182,11 +182,9 @@ public ElementTree parseLine(final String line, final FileContext context) {
                 context.destroySection();
                 context.destroyUnit();
                 context.indent--;
-            }
-            if (actual == 0) { // allow different indentation per member
-                context.setIndentUnit(null);
-            }
-        } else if (actual != expected) throw new ScriptParseError(context.lineNumber(), "Wrong indent.");
+            } // allow different indentation per member
+            if (actual == 0) context.setIndentUnit(null);
+        } else if (actual != expected) throw new ScriptParseError(context.lineNumber(), "Incorrect indentation.");
         final String statement = line.trim();
         if (statement.isBlank()) return null;
         if (line.endsWith(":")) {
@@ -239,7 +237,7 @@ public ElementTree assembleExpression(String expression, final Type expected, fi
             if (!handler.allowAsInputFor(expected)) continue;
             final Pattern.Match match = handler.match(expression, context);
             if (match == null) continue;
-            if (!match.matcher().group().equals(expression)) continue;
+            if (!match.equals(expression)) continue;
             final Type[] types = match.expected();
             final String[] inputs = match.groups();
             if (inputs.length < types.length) continue;
@@ -268,6 +266,18 @@ public Class<?> load(byte[] bytecode, String name) {
         return Skript.currentLoader().loadClass(name, bytecode);
     }
 
+    @Override
+    public boolean addLibrary(Library library) {
+        if (libraries.contains(library)) return false;
+        this.libraries.add(0, library); // need to make sure it goes before skript
+        return true;
+    }
+    
+    @Override
+    public boolean removeLibrary(Library library) {
+        return libraries.remove(library);
+    }
+    
     @Override
     public PostCompileClass[] compile(InputStream stream, Type name) {
         return compile(unstream(stream), name);
@@ -282,12 +292,10 @@ public PostCompileClass[] compile(String source, Type path) {
         final FileContext context = new FileContext(path);
         context.libraries.addAll(libraries);
         for (final Library library : libraries) {
-            for (final Type type : library.getTypes()) {
-                context.registerType(type);
-            }
+            for (final Type type : library.getTypes()) context.registerType(type);
         }
         final List<String> lines = this.removeComments(source);
-        for (String line : lines) {
+        for (final String line : lines) {
             context.lineNumber++;
             context.line = null;
             if (line.isBlank()) continue;
@@ -302,30 +310,14 @@ public PostCompileClass[] compile(String source, Type path) {
                 throw new ScriptCompileError(context.lineNumber, "Unknown error during compilation:", ex);
             }
         }
-        for (int i = 0; i < context.units.size(); i++) {
-            context.destroyUnit();
-        }
-        for (int i = 0; i < context.sections.size(); i++) {
-            context.destroySection();
-        }
+        context.destroyUnits();
+        context.destroySections();
         return context.compile();
     }
 
-    @Override
-    public boolean addLibrary(Library library) {
-        if (libraries.contains(library)) return false;
-        libraries.add(0, library); // need to make sure it goes before skript
-        return true;
-    }
-    
-    @Override
-    public boolean removeLibrary(Library library) {
-        return libraries.remove(library);
-    }
-    
     int trueIndent(final String line, final String unit) {
-        int indent = 0, offset = 0;
         if (unit == null) return 0;
+        int indent = 0, offset = 0;
         final int length = unit.length();
         while (line.startsWith(unit, offset)) {
             indent++;

src/main/java/org/byteskript/skript/compiler/SkriptCompiler.java

@@ -27,14 +27,14 @@ public SkriptLangSpec getLanguage() {
 
     public abstract Class<?> load(byte[] bytecode, String name);
 
+    public abstract boolean addLibrary(Library library);
+    
+    public abstract boolean removeLibrary(Library library);
+    
     public abstract PostCompileClass[] compile(InputStream stream, Type name);
 
     public abstract PostCompileClass[] compile(InputStream file, String path);
 
     public abstract PostCompileClass[] compile(String file, Type path);
 
-    public abstract boolean addLibrary(Library library);
-    
-    public abstract boolean removeLibrary(Library library);
-    
 }

src/main/java/org/byteskript/skript/runtime/Script.java

@@ -59,6 +59,7 @@ public final class Script {
     }
 
     @Ignore
+    @SuppressWarnings("unchecked")
     Script(boolean init, Skript skript, File sourceFile, Class<?>... classes) {
         this.skript = skript;
         this.sourceFile = sourceFile;

src/main/java/org/byteskript/skript/runtime/Skript.java

@@ -30,6 +30,7 @@
 import java.nio.file.Path;
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
 
 @Description("""
     This class is the entry-point for any program or library using ByteSkript.
@@ -533,7 +534,7 @@ This can compile only simple scripts (which create a single class file.)
     @CompilerDependent
     public void compileScript(final InputStream input, final String name, final OutputStream target)
         throws IOException {
-        final PostCompileClass datum = compileScript(input, name);
+        final PostCompileClass datum = this.compileScript(input, name);
         target.write(datum.code());
     }
 
@@ -592,6 +593,44 @@ public PostCompileClass[] compileScripts(final File root) throws IOException {
         return scripts.toArray(new PostCompileClass[0]);
     }
 
+    @Description("""
+        Compiles all scripts in the root file to code representations.
+        These representations may be loaded, written to files or otherwise used.
+        """)
+    @GenerateExample
+    @CompilerDependent
+    public Promise<PostCompileClass[]> compileScriptsAsync(final File root) throws IOException {
+        if (!root.exists()) throw new ScriptLoadError("Root folder does not exist.");
+        if (!root.isDirectory()) throw new ScriptLoadError("Root must be a folder.");
+        final List<File> files = getFiles(new ArrayList<>(), root.toPath());
+        final CompletableFuture<PostCompileClass[]> future = new CompletableFuture<>();
+        final Promise<PostCompileClass[]> promise = new Promise<>(future);
+        final Collection<PostCompileClass> scripts = Collections.synchronizedCollection(new ArrayList<>());
+        final AtomicInteger integer = new AtomicInteger();
+        for (final File file : files) {
+            if (file == null) continue;
+            if (!file.getName().endsWith(".bsk")) continue;
+            try (final InputStream stream = new FileInputStream(file)) {
+                final String name = this.getClassName(file, root);
+                this.compileComplexScriptAsync(stream, name)
+                    .whenComplete(output -> {
+                        scripts.addAll(Arrays.asList(output));
+                        integer.incrementAndGet();
+                    });
+            }
+        }
+        final int expected = files.size();
+        future.completeAsync(() -> {
+            while (integer.get() < expected) {
+                try {
+                    Thread.sleep(5);
+                } catch (InterruptedException e) {}
+            }
+            return scripts.toArray(new PostCompileClass[0]);
+        }, this.executor);
+        return promise;
+    }
+    
     @Description("""
         Compiles a single script to its class files.
         This method may be unavailable in some distributions.
@@ -614,6 +653,27 @@ public PostCompileClass compileScript(final String code, final String name) {
         return compileScript(new ByteArrayInputStream(code.getBytes(StandardCharsets.UTF_8)), name);
     }
 
+    @Description("""
+        Compiles a simple script from its string source to a memory class.
+        This method may be unavailable in some distributions.
+        """)
+    @GenerateExample
+    @CompilerDependent
+    public Promise<PostCompileClass[]> compileScriptAsync(final String code, final String name) {
+        return compileComplexScriptAsync(new ByteArrayInputStream(code.getBytes(StandardCharsets.UTF_8)), name);
+    }
+    
+    @Description("""
+        Compiles a single script to its class files.
+        This version runs in the background and returns a promise
+        This method may be unavailable in some distributions.
+        """)
+    @GenerateExample
+    @CompilerDependent
+    public Promise<PostCompileClass[]> compileComplexScriptAsync(final InputStream stream, final String name) {
+        return compiler.compileAsync(stream, new Type(name), this);
+    }
+    
     @Description("""
         Unloads a script by its main class.
         This is a destructive operation.

src/main/java/org/byteskript/skript/runtime/internal/ModifiableCompiler.java

@@ -11,11 +11,14 @@
 import mx.kenzie.foundation.language.PostCompileClass;
 import org.byteskript.skript.api.Document;
 import org.byteskript.skript.api.Library;
+import org.byteskript.skript.runtime.Skript;
 
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 
 @Description("""
     This is a template for a modifiable compiler.
@@ -27,12 +30,6 @@ public interface ModifiableCompiler {
 
     Class<?> load(byte[] bytecode, String name);
 
-    PostCompileClass[] compile(InputStream stream, Type name);
-    
-    PostCompileClass[] compile(InputStream file, String path);
-    
-    PostCompileClass[] compile(String file, Type path);
-    
     boolean addLibrary(Library library);
 
     boolean removeLibrary(Library library);
@@ -50,4 +47,26 @@ default Document[] generateDocumentation() {
 
     Library[] getLibraries();
 
+    default Promise<PostCompileClass[]> compileAsync(InputStream stream, Type name, Skript skript) {
+        return this.background(() -> compile(stream, name), skript);
+    }
+    
+    default Promise<PostCompileClass[]> background(Supplier<PostCompileClass[]> supplier, Skript skript) {
+        return new Promise<>(CompletableFuture.supplyAsync(supplier, skript.getExecutor()));
+    }
+    
+    PostCompileClass[] compile(InputStream stream, Type name);
+    
+    default Promise<PostCompileClass[]> compileAsync(InputStream file, String path, Skript skript) {
+        return this.background(() -> compile(file, path), skript);
+    }
+    
+    PostCompileClass[] compile(InputStream file, String path);
+    
+    default Promise<PostCompileClass[]> compileAsync(String file, Type path, Skript skript) {
+        return this.background(() -> compile(file, path), skript);
+    }
+    
+    PostCompileClass[] compile(String file, Type path);
+    
 }

src/main/java/org/byteskript/skript/runtime/internal/Promise.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2022 ByteSkript org (Moderocky)
+ * View the full licence information and permissions:
+ * https://github.com/Moderocky/ByteSkript/blob/master/LICENSE
+ */
+
+package org.byteskript.skript.runtime.internal;
+
+import org.byteskript.skript.error.ScriptCompileError;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.*;
+import java.util.function.Consumer;
+
+public class Promise<Type> implements Future<Type> {
+    
+    protected final CompletableFuture<Type> future;
+    protected volatile Type type;
+    
+    public Promise(CompletableFuture<Type> future) {
+        this.future = future;
+    }
+    
+    public boolean ready() {
+        return future.isDone();
+    }
+    
+    public void cancel() {
+        this.future.cancel(true);
+    }
+    
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        return future.cancel(mayInterruptIfRunning);
+    }
+    
+    @Override
+    public boolean isCancelled() {
+        return future.isCancelled();
+    }
+    
+    @Override
+    public boolean isDone() {
+        return future.isDone();
+    }
+    
+    public synchronized Type get() {
+        if (type == null) await();
+        return type;
+    }
+    
+    public synchronized void await() {
+        try {
+            this.type = future.get();
+        } catch (InterruptedException | ExecutionException ex) {
+            throw new ScriptCompileError(-1, ex);
+        }
+    }
+    
+    @Override
+    public synchronized Type get(long timeout, @NotNull TimeUnit unit) {
+        try {
+            return type = future.get(timeout, unit);
+        } catch (InterruptedException | ExecutionException | TimeoutException ex) {
+            throw new ScriptCompileError(-1, ex);
+        }
+    }
+    
+    public void whenComplete(Consumer<Type> consumer) {
+        this.future.thenAccept(consumer);
+    }
+    
+}

src/main/java/skript.java

@@ -79,7 +79,7 @@ public static double to_radians(double number) {
         return Math.toRadians(number);
     }
 
-    public static Number abs(Object object) {
+    public static Number abs(Object object) { // the instance-checks make sure the correct absolute is used
         if (object == null) return 0;
         if (object instanceof Byte number) return Math.abs(number);
         if (object instanceof Short number) return Math.abs(number);