AbstractMacro fix & Rest

Author: Kriptel

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `hasErrorHandler` variable to RuleScript and RuleScriptInterp.
 - `errorHandler` variable to RuleScript and RuleScriptInterp.
 - Key => value iterator.
+- Rest.
 - `superInstance` variable to RuleScriptInterp.
 - `onMeta` callback in RuleScriptInterp.
 - Classes (MODULE mode only).
@@ -33,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - rulescript.parsers.HxParser.HScriptParserPlus.moduleDeclsToExpr.
 
 ### Fixed
+- Fixed bug when AbstractMacro can't find abstracts in a module other than it's name.
 - Fixed `using` error on Haxe Interpreter.
 - Fixed compile error on non-cpp targets.
 - Improve `using` resolve function.

README.md

@@ -15,6 +15,7 @@ Hscript addon with script classes, imports, usings, properties, string interpola
 - [Abstracts in script](#abstracts-in-script)
 - [Key => value iterator](#key--value-iterator)
 - [`??` and `??=` operators](#and--operators)
+- [Rest](#rest)
 
 ### Package
 ```haxe
@@ -82,7 +83,6 @@ trace(a); // Hello World
 ```
 
 ### String interpolation
-RuleScript supports [String Interpolation](https://haxe.org/manual/lf-string-interpolation.html), but you can only use identifiers, double quotes string, calls without arguments and `+` operator.
 ```haxe
 var a = 'Hello';
 trace('RuleScript: $a World'); // RuleScript: Hello World
@@ -173,6 +173,19 @@ a = null;
 a ??= 'world';
 trace(a) // world
 ```
+
+# Rest
+```haxe
+var f = function(hello:String, ...rest:Dynamic)
+{
+	return '$hello: ' + rest.join(' ');
+}
+
+trace(f('Rulescript','Hello','World','!')); // Rulescript: Hello World !
+
+trace(f('Rulescript',...['Hello','World','!'])); // Rulescript: Hello World !
+```
+
 # Limitations
 
 - Script `using` callback supports max number of arguments is 8.

rulescript/RuleScript.hx

@@ -90,6 +90,8 @@ class RuleScript
 
 	public var interp:RuleScriptInterp;
 
+	public var scriptName(get, set):String;
+
 	public var superInstance(get, set):Dynamic;
 
 	public var variables(get, set):Map<String, Dynamic>;
@@ -124,6 +126,16 @@ class RuleScript
 	public function getParser<T:Parser>(?parserClass:Class<T>):T
 		return cast parser;
 
+	function get_scriptName():String
+	{
+		return interp.scriptName;
+	}
+
+	function set_scriptName(v:String):String
+	{
+		return interp.scriptName = v;
+	}
+
 	function get_superInstance():Dynamic
 	{
 		return interp.superInstance;

rulescript/RuleScriptInterp.hx

@@ -8,6 +8,8 @@ using rulescript.Tools;
 
 class RuleScriptInterp extends hscript.Interp
 {
+	public var scriptName:String;
+
 	public var scriptPackage:String = '';
 
 	public var imports:Map<String, Dynamic> = [];
@@ -44,6 +46,18 @@ class RuleScriptInterp extends hscript.Interp
 		#end
 	}
 
+	override public function posInfos():haxe.PosInfos
+	{
+		#if hscriptPos
+		if (curExpr != null)
+			return cast {fileName: scriptName ?? curExpr.origin, lineNumber: curExpr.line};
+		#end
+		return cast {
+			fileName: scriptName ?? "hscript",
+			lineNumber: 0
+		};
+	}
+
 	override function initOps()
 	{
 		super.initOps();
@@ -205,6 +219,31 @@ class RuleScriptInterp extends hscript.Interp
 				else
 					forLoopKeyValue(key, value, it, e);
 				return null;
+			case ECall(e, params):
+				var args = new Array();
+				for (p in params)
+				{
+					if (p.getExpr().match(EUnop('...', true, _)))
+						for (arg in cast(this.expr(switch (p.getExpr())
+						{
+							case EUnop(op, prefix, e): e;
+							default: null;
+						}), Array<Dynamic>))
+							args.push(arg);
+					else
+						args.push(this.expr(p));
+				}
+
+				switch (hscript.Tools.expr(e))
+				{
+					case EField(e, f):
+						var obj = this.expr(e);
+						if (obj == null)
+							error(EInvalidAccess(f));
+						return fcall(obj, f, args);
+					default:
+						return call(null, this.expr(e), args);
+				}
 			case EFunction(params, fexpr, name, _):
 				if (name == 'new')
 					__constructor = expr;

rulescript/macro/AbstractMacro.hx

@@ -1,56 +1,59 @@
 package rulescript.macro;
 
+#if macro
 import haxe.macro.Context;
 import haxe.macro.Expr;
+import rulescript.macro.MacroTools.ClassPath;
 import sys.FileSystem;
 import sys.io.File;
+#end
 
 using StringTools;
 
-#if !macro
-@:keep
-@:build(rulescript.macro.TouchMacro.touch())
-#end
 class AbstractMacro
 {
-	/**
-	 * Converts abstract to class
-	 */
-	macro public static function buildAbstract(name:String, pack:String):Array<Field>
+	static final targetPackage:String = "rulescript.__abstracts";
+
+	macro public static function build():Array<Field>
 	{
-		var fields = Context.getBuildFields();
-		var pos = Context.currentPos();
+		var type = switch (Context.getLocalType())
+		{
+			case TInst(t, params):
+				switch (t.get().kind)
+				{
+					case KAbstractImpl(a):
+						a.get();
+					default:
+						null;
+				}
+			case t:
+				Context.error('Failed to build non-abstract type', Context.currentPos());
+				null;
+		}
 
-		var type = Context.getLocalClass();
+		var classPath:ClassPath = MacroTools.parseClassPath(type.module.endsWith(type.name) ? type.module : type.module + '.' + type.name);
 
-		var isEnum:Bool = type.get().meta.has(':enum');
+		var fields = Context.getBuildFields();
+		var pos = Context.currentPos();
+		var isEnum:Bool = type.meta.has(':enum');
 
 		var cl = macro class {};
 
 		cl.meta.push({pos: pos, name: ':keep'});
+		cl.meta.push({pos: pos, name: ':noCompletion'});
 
 		var imports = Context.getLocalImports();
 
 		imports.push({
-			path: name.split('.').map(s -> {
+			path: classPath.fullPath.split('.').map(s -> {
 				name: s,
 				pos: pos
 			}),
 			mode: INormal
 		});
 
-		if (name.contains('.'))
-		{
-			var list = name.split('.');
-
-			while (list.length > 1)
-				pack += '.' + list.shift();
-
-			name = list[0];
-		}
-
-		cl.name = '_' + name;
-		cl.pack = pack.split('.');
+		cl.name = '_' + classPath.name;
+		cl.pack = classPath.pack.split('.');
 
 		for (f in fields)
 		{
@@ -76,7 +79,7 @@ class AbstractMacro
 				});
 		}
 
-		Context.defineModule('$pack._$name', [cl], imports);
+		Context.defineModule('$targetPackage.${classPath.pack}._${classPath.name}', [cl], imports);
 
 		return fields;
 	}

rulescript/macro/Converter.hx

@@ -10,7 +10,6 @@ using StringTools;
 
 class Converter
 {
-	// Language server shows errors...
 	public static macro function init()
 	{
 		var files:Array<String> = [];
@@ -26,7 +25,11 @@ class Converter
 						abstractsList.push(abs);
 
 		for (name in abstractsList)
-			Compiler.addMetadata('@:build(rulescript.macro.AbstractMacro.buildAbstract("$name","rulescript.__abstracts"))', name);
+		{
+			var classPath = MacroTools.parseClassPath(name);
+			Compiler.addMetadata('@:build(rulescript.macro.AbstractMacro.build())', '${classPath.pack}.${classPath.name}');
+		}
+
 		return null;
 	}
 

rulescript/macro/MacroTools.hx

@@ -4,8 +4,34 @@ package rulescript.macro;
 import haxe.macro.Context;
 import haxe.macro.Expr;
 
+using StringTools;
+
 class MacroTools
 {
+	public static function parseClassPath(classPath:String):ClassPath
+	{
+		if (classPath == null || classPath.length == 0)
+			return null;
+
+		var path:Array<String> = classPath.split('.');
+
+		var pack:Array<String> = [];
+
+		while (path[0].charAt(0) == path[0].charAt(0).charAt(0).toLowerCase())
+			pack.push(path.shift());
+
+		var module:String = null;
+		if (path.length > 1)
+			module = path.shift();
+
+		return {
+			fullPath: classPath,
+			name: path[0],
+			module: module,
+			pack: pack.join('.')
+		}
+	}
+
 	/**
 	 * Convert Expr function to function
 	 */
@@ -21,6 +47,14 @@ class MacroTools
 	}
 }
 
+typedef ClassPath =
+{
+	var fullPath:String;
+	var name:String;
+	var ?module:String;
+	var pack:String;
+};
+
 typedef ClassFunctionArg =
 {
 	var name:String;