Improve the bridge compiler capabilities.

Author: Moderocky

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.byteskript</groupId>
     <artifactId>byteskript</artifactId>
-    <version>1.0.27</version>
+    <version>1.0.28</version>
     <name>ByteSkript</name>
     <description>A compiled JVM implementation of the Skript language.</description>
 
@@ -68,7 +68,7 @@
         <dependency>
             <groupId>mx.kenzie</groupId>
             <artifactId>foundation</artifactId>
-            <version>1.1.6</version>
+            <version>1.1.7</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
@@ -104,7 +104,7 @@
         <dependency>
             <groupId>org.jetbrains</groupId>
             <artifactId>annotations</artifactId>
-            <version>22.0.0</version>
+            <version>23.0.0</version>
             <scope>provided</scope>
         </dependency>
         <dependency>

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

@@ -62,6 +62,7 @@ public Class<?> createClass()
             final Class<?> parameter = parameters[i];
             visitor.visitVarInsn(20 + this.instructionOffset(argument), i);
             this.boxAtomic(visitor, parameter);
+            this.conform(visitor, parameter);
             visitor.visitTypeInsn(192, Type.getInternalName(this.getUnboxingType(parameter)));
             this.unbox(visitor, parameter);
         }
@@ -100,6 +101,12 @@ protected void boxAtomic(MethodVisitor visitor, Class<?> parameter) {
             visitor.visitMethodInsn(184, Type.getInternalName(AtomicVariable.class), "unwrap", "(Ljava/lang/Object;)Ljava/lang/Object;", false);
     }
 
+    protected void conform(MethodVisitor visitor, Class<?> parameter) {
+        if (parameter == Object.class || parameter == AtomicVariable.class) return;
+        visitor.visitLdcInsn(Type.getObjectType(Type.getInternalName(this.getUnboxingType(parameter))));
+        visitor.visitMethodInsn(184, "org/byteskript/skript/runtime/internal/ExtractedSyntaxCalls", "convert", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", false);
+    }
+    
     protected Class<?> getUnboxingType(Class<?> primitive) {
         if (!primitive.isPrimitive()) return primitive;
         if (primitive == boolean.class) return Boolean.class;

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

@@ -75,8 +75,7 @@
 import org.byteskript.skript.runtime.type.DataList;
 import org.byteskript.skript.runtime.type.DataMap;
 
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
 import java.net.URL;
 import java.security.CodeSource;
 import java.util.ArrayList;
@@ -129,7 +128,10 @@ private SkriptLangSpec() {
         registerConverter(String.class, Long.class, Long::valueOf);
         registerConverter(String.class, Number.class, Double::valueOf);
         registerConverter(String.class, Error.class, Error::new);
+        registerConverter(String.class, File.class, File::new);
         registerConverter(String.class, Class.class, Skript::findAnyClass);
+        registerConverter(File.class, OutputStream.class, FileOutputStream::new);
+        registerConverter(File.class, InputStream.class, FileInputStream::new);
         registerConverter(Object.class, String.class, Object::toString);
         registerSyntax(CompileState.ROOT,
             new TypeMember(),
@@ -145,6 +147,7 @@ private SkriptLangSpec() {
         registerSyntax(CompileState.MEMBER_BODY,
             new Verify(),
             new Trigger(),
+            new Parameters(),
             new ReturnType(),
             new SyntaxEntry(),
             new EffectEntry(),

src/main/java/org/byteskript/skript/lang/syntax/entry/Parameters.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2021 ByteSkript org (Moderocky)
+ * View the full licence information and permissions:
+ * https://github.com/Moderocky/ByteSkript/blob/master/LICENSE
+ */
+
+package org.byteskript.skript.lang.syntax.entry;
+
+import mx.kenzie.foundation.MethodBuilder;
+import mx.kenzie.foundation.Type;
+import mx.kenzie.foundation.compiler.State;
+import org.byteskript.skript.api.note.Documentation;
+import org.byteskript.skript.api.syntax.SimpleEntry;
+import org.byteskript.skript.compiler.*;
+import org.byteskript.skript.error.ScriptCompileError;
+import org.byteskript.skript.lang.element.StandardElements;
+
+@Documentation(
+    name = "Function Parameter Types",
+    description = """
+        Specify explicit parameter types of a function.
+        This can be used for overriding functions in types.
+        This can also be used for automatic type conformity.
+        """,
+    examples = {
+        """
+            function my_func (a, b):
+                parameters: string, number
+                return: String
+                trigger:
+                    return "hello " + {a}
+                    """
+    }
+)
+public class Parameters extends SimpleEntry {
+    
+    public Parameters() {
+        super(SkriptLangSpec.LIBRARY, StandardElements.METADATA, "parameters: %Types%");
+    }
+    
+    @Override
+    public void compile(Context context, Pattern.Match match) {
+        final String[] names = match.<String>meta().split(",");
+        final MethodBuilder builder = context.getMethod();
+        final Type[] types = builder.getErasure().parameterTypes();
+        for (int i = 0; i < names.length && i < types.length; i++) {
+            final String name = names[i].trim();
+            if (name.isEmpty()) {
+                context.getError().addHint(this, "All values need to be provided in a `x, y, z` comma-separated list.");
+                throw new ScriptCompileError(context.lineNumber(), "All values in " + match.meta() + " need to be provided in a `x, y, z` comma-separated list.");
+            } else {
+                final Type type = context.findType(name);
+                if (type != null) builder.setParameter(i, type);
+                else builder.setParameter(i, new Type(name.replace('.', '/')));
+            }
+        }
+        context.setState(CompileState.MEMBER_BODY);
+    }
+    
+    @Override
+    public Pattern.Match match(String thing, Context context) {
+        if (!thing.startsWith("parameters: ")) return null;
+        final Pattern.Match match = super.match(thing, context);
+        if (match == null) return null;
+        final String name = match.groups()[0].trim();
+        if (name.contains("\"")) {
+            context.getError().addHint(this, "Types should not be written inside quotation marks.");
+            return null;
+        }
+        return new Pattern.Match(Pattern.fakeMatcher(thing), name);
+    }
+    
+    @Override
+    public boolean allowAsInputFor(Type type) {
+        return false;
+    }
+    
+    @Override
+    public boolean allowedIn(State state, Context context) {
+        return super.allowedIn(state, context) && context.hasFlag(AreaFlag.IN_FUNCTION);
+    }
+    
+    
+}

src/main/java/org/byteskript/skript/lang/syntax/flow/error/CatchSection.java

@@ -63,6 +63,19 @@ public boolean allowedIn(State state, Context context) {
             && context.getMethod() != null;
     }
 
+    public void compileTogether(Context context, Pattern.Match match, TryCatchTree tree) throws Throwable {
+        final ElementTree holder = context.getCompileCurrent().nested()[0];
+        tree.branch(context);
+        store:
+        {
+            holder.type = StandardHandlers.SET;
+            holder.compile = true;
+            holder.preCompile(context);
+            holder.compile(context);
+        }
+        context.setState(CompileState.CODE_BODY);
+    }
+    
     @Override
     public void onSectionExit(Context context, SectionMeta meta) {
         final ProgrammaticSplitTree current;
@@ -87,17 +100,4 @@ public void preCompileInline(Context context, Pattern.Match match) throws Throwa
         this.preCompile(context, match);
     }
 
-    public void compileTogether(Context context, Pattern.Match match, TryCatchTree tree) throws Throwable {
-        final ElementTree holder = context.getCompileCurrent().nested()[0];
-        tree.branch(context);
-        store:
-        {
-            holder.type = StandardHandlers.SET;
-            holder.compile = true;
-            holder.preCompile(context);
-            holder.compile(context);
-        }
-        context.setState(CompileState.CODE_BODY);
-    }
-    
 }

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

@@ -298,12 +298,18 @@ public static <To> To convert(Object from, Class<To> to) {
      */
     @SuppressWarnings("unchecked")
     public static <From, To> To convert(From from, Class<To> to, boolean fail) {
-        if (to.isInstance(from)) return to.cast(from);
-        final Skript instance = findInstance();
-        final Converter<From, To> converter = (Converter<From, To>) instance.getConverter(from.getClass(), to);
-        if (converter != null) return converter.convert(from);
-        if (fail) throw new ScriptRuntimeError("Unable convert '" + from + "' to type " + to.getSimpleName() + ".");
-        else return null;
+        try {
+            if (to.isInstance(from)) return to.cast(from);
+            final Skript instance = findInstance();
+            final Converter<From, To> converter = (Converter<From, To>) instance.getConverter(from.getClass(), to);
+            if (converter != null) return converter.convert(from);
+            if (fail) throw new ScriptRuntimeError("Unable convert '" + from + "' to type " + to.getSimpleName() + ".");
+            else return null;
+        } catch (Throwable ex) {
+            if (fail)
+                throw new ScriptRuntimeError("Unable convert '" + from + "' to type " + to.getSimpleName() + ".", ex);
+            else return null;
+        }
     }
 
     @SuppressWarnings("unchecked")
@@ -322,6 +328,11 @@ public <From, To> void registerConverter(Class<From> from, Class<To> to, Convert
         this.converters.put(data, converter);
     }
 
+    public <From, To> void unregisterConverter(Class<From> from, Class<To> to) {
+        final Converter.Data data = new Converter.Data(from, to);
+        this.converters.remove(data);
+    }
+    
     @Description("""
         Gets the parent class-loader attached to this Skript runtime.
         This is used to search available libraries and scripts for classes.

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

@@ -43,7 +43,11 @@ public static Object convert(Object from, Object object) {
         if (to.isAssignableFrom(from.getClass())) return to.cast(from);
         final Converter converter = findInstance().getConverter(from.getClass(), to);
         if (converter == null) return from;
-        return converter.convert(from);
+        try {
+            return converter.convert(from);
+        } catch (Throwable ex) {
+            throw new ScriptRuntimeError("Error while converting '" + from + "' to a " + to.getSimpleName(), ex);
+        }
     }
 
     public static void handleTestError(Throwable throwable) {

src/main/java/org/byteskript/skript/runtime/type/Converter.java

@@ -9,7 +9,7 @@
 @FunctionalInterface
 public interface Converter<From, To> {
 
-    To convert(From from);
+    To convert(From from) throws Throwable;
 
     record Data(Class<?> from, Class<?> to) {}
 

src/main/java/unsafe.java

@@ -0,0 +1,49 @@
+import mx.kenzie.mirror.MethodAccessor;
+import org.byteskript.skript.runtime.Skript;
+import org.byteskript.skript.runtime.UnsafeAccessor;
+import org.byteskript.skript.runtime.type.DataList;
+
+import java.util.Arrays;
+
+/**
+ * This is the Java implementation of the 'unsafe' namespace functions.
+ * Some implementations may re-implement this in Skript itself.
+ * <p>
+ * The unusual casing is to match Skript's code-style.
+ */
+public class unsafe extends UnsafeAccessor {
+    
+    public static DataList get_threads() {
+        final DataList list = new DataList();
+        final int count = get_thread_count();
+        final Thread[] threads = new Thread[count];
+        Skript.THREAD_GROUP.enumerate(threads);
+        list.addAll(Arrays.asList(threads));
+        return list;
+    }
+    
+    public static int get_thread_count() {
+        return Skript.THREAD_GROUP.activeCount();
+    }
+    
+    public static void await_load(Class<?> type) {
+        UNSAFE.ensureClassInitialized(type);
+    }
+    
+    public static void register_converter(Class<Object> from, Class<Object> to, MethodAccessor<?> function) {
+        final Skript skript = get_runtime();
+        skript.registerConverter(from, to, function::invoke);
+    }
+    
+    public static Skript get_runtime() {
+        final Skript skript = Skript.localInstance();
+        if (skript != null) return skript;
+        return Skript.currentInstance();
+    }
+    
+    public static void unregister_converter(Class<Object> from, Class<Object> to) {
+        final Skript skript = get_runtime();
+        skript.unregisterConverter(from, to);
+    }
+    
+}

src/test/resources/tests/parameters.bsk

@@ -0,0 +1,30 @@
+
+function blob (a, b, c):
+    parameters: string
+    trigger:
+        assert {a} is a string
+        return {c}
+
+function blob (a, b):
+    parameters: string, integer
+    trigger:
+        assert {a} is a string
+        assert {b} is a number
+        return {a} + " " + {b}
+
+
+function blob (a):
+    parameters: string, number
+    trigger:
+        assert {a} is a string
+        return {a}
+
+function test:
+    trigger:
+        assert blob("hello", 2) is "hello 2"
+        assert blob("hello", "2") is "hello 2"
+        assert blob(2, 1) is "2 1"
+        assert blob(2, "1") is "2 1"
+        assert blob(1, 1, 2) is 2
+        assert blob(1) is "1"
+        return true