--macrolog option (shows messages from make compile time)

ilya-ku · ilya-ku · commit e7ae7cf03cae · 2017-10-10T12:35:28.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,7 @@
 - `Task.empty(name, desc)` creates empty task
 - Prints property-map on start
 - Flash Player trust location PER USER for macOS and Windows
+- `--macrolog` enabled traces from compile-time
 
 # v0.1.6
 
diff --git a/run.n b/run.n
diff --git a/src/hxmake/Project.hx b/src/hxmake/Project.hx
@@ -40,15 +40,15 @@ class Project {
 	var _moduleGraph:ModuleGraph;
 
 	function new(buildArguments:Array<String>, isCompiler:Bool) {
-		MakeLog.initialize(buildArguments);
+		args = isCompiler ? buildArguments : buildArguments.concat(Sys.args());
+		properties = parsePropertyMap(args);
+
+		MakeLog.initialize(hasProperty("--silent"), hasProperty("--verbose"));
 
 		if (isCompiler) {
 			MakeLog.trace("[MakeProject] Compiler mode");
 		}
 
-		args = isCompiler ? buildArguments : buildArguments.concat(Sys.args());
-		properties = parsePropertyMap(args);
-
 		_moduleGraph = @:privateAccess new ModuleGraph();
 		_taskGraph = @:privateAccess new TaskGraph(args, _moduleGraph.modules);
 	}
@@ -67,6 +67,10 @@ class Project {
 		return properties.exists(name) ? properties.get(name) : null;
 	}
 
+	public function hasProperty(name:String):Bool {
+		return property(name) != null;
+	}
+
 	function run() {
 		var startTime = Timer.stamp();
 
diff --git a/src/hxmake/cli/MakeLog.hx b/src/hxmake/cli/MakeLog.hx
@@ -8,7 +8,7 @@ import hxmake.cli.logging.LogLevel;
 @:final
 class MakeLog {
 
-	public static var logger(default, null):Logger = new Logger();
+	public static var logger(default, null):Logger;
 
 	public inline static function trace(message:Dynamic, ?position:PosInfos) {
 		logger.trace(message, position);
@@ -30,13 +30,11 @@ class MakeLog {
 		logger.error(message, position);
 	}
 
-	public static function initialize(args:Array<String>) {
-		if(args.indexOf("--silent") >= 0) {
-			logger.setFilter(LogLevel.FILTER_SILENT);
-		}
-		else if(args.indexOf("--verbose") >= 0) {
-			logger.setFilter(LogLevel.FILTER_VERBOSE);
-		}
+	public static function initialize(silent:Bool, verbose:Bool) {
+		var filter = LogLevel.FILTER_STD;
+		if(verbose) filter = LogLevel.FILTER_VERBOSE;
+		if(silent) filter = LogLevel.FILTER_SILENT;
+		logger = new Logger(filter);
 		Log.trace = onHaxeTrace;
 	}
 
diff --git a/src/hxmake/cli/logging/Logger.hx b/src/hxmake/cli/logging/Logger.hx
@@ -4,20 +4,18 @@ import haxe.PosInfos;
 
 class Logger {
 
-	public static var current(default, null):Logger = new Logger();
-
 	var _filter:Int;
 	var _colors:Array<AnsiColor> = [];
 	var _levels:Array<String> = [];
 	var _positions:Array<Bool> = [];
 
-	public function new() {
+	public function new(filter:Int) {
 		setLevelFormat(LogLevel.TRACE, "[T] ", AnsiColor.GREY, true);
 		setLevelFormat(LogLevel.DEBUG, "[D] ", AnsiColor.WHITE, true);
 		setLevelFormat(LogLevel.INFO, "", AnsiColor.CYAN, false);
 		setLevelFormat(LogLevel.WARNING, "[WARNING] ", AnsiColor.YELLOW, false);
 		setLevelFormat(LogLevel.ERROR, "[ERROR] ", AnsiColor.RED, false);
-		setFilter(LogLevel.FILTER_STD);
+		setFilter(filter);
 	}
 
 	inline public function trace(message:Dynamic, ?position:PosInfos) {
@@ -43,11 +41,11 @@ class Logger {
 	public function print(data:Dynamic, level:LogLevel, ?position:PosInfos) {
 		var text = Std.string(data);
 
-		if((_filter & (1 << level)) == 0) {
+		if ((_filter & (1 << level)) == 0) {
 			return;
 		}
 
-		if(_positions[level]) {
+		if (_positions[level]) {
 			text = position.fileName + ":" + position.lineNumber + " " + text;
 		}
 
diff --git a/src/hxmake/macr/CompileTime.hx b/src/hxmake/macr/CompileTime.hx
@@ -14,4 +14,10 @@ class CompileTime {
 		Compiler.addClassPath(makePath);
 		Compiler.include("", true, null, [makePath]);
 	}
+
+	public static function log(message:String) {
+		#if hxmake_macrolog
+		Sys.println('[MACRO] $message');
+		#end
+	}
 }
diff --git a/src/hxmake/macr/ModuleMacro.hx b/src/hxmake/macr/ModuleMacro.hx
@@ -1,12 +1,11 @@
 package hxmake.macr;
 
-import hxmake.cli.MakeLog;
-import haxe.macro.Expr.Access;
-import sys.FileSystem;
 import haxe.io.Path;
-import haxe.macro.Type;
 import haxe.macro.Context;
+import haxe.macro.Expr.Access;
 import haxe.macro.Expr;
+import haxe.macro.Type;
+import sys.FileSystem;
 
 using StringTools;
 
@@ -20,42 +19,44 @@ class ModuleMacro {
 		var modulePath = getModulePath(Context.getLocalModule());
 		var childrenExprs:Array<Expr> = [];
 
-		MakeLog.trace(modulePath);
+		CompileTime.log(modulePath);
 		var changedModulePath:Array<String> = MacroHelper.extractMetaStrings(cls.meta, ":module_path");
-		if(changedModulePath.length > 0) {
+		if (changedModulePath.length > 0) {
 			var parentPath = modulePath;
 			modulePath = FileSystem.absolutePath(Path.join([modulePath, changedModulePath[0]]));
-			MakeLog.trace("CHANGED TO: " + modulePath);
+			CompileTime.log("CHANGED TO: " + modulePath);
 			//childrenExprs.push(macro hxmake.core.CompiledProjectData.createModuleConnection($v{modulePath}, $v{childModulePath}));
 		}
 
 		var guessModuleName = modulePath.split("/").pop();
 
 		var includes:Array<String> = MacroHelper.extractMetaStrings(cls.meta, ":include");
-		for(include in includes) {
+		for (include in includes) {
 			var childModulePath = FileSystem.absolutePath(Path.join([modulePath, include]));
-			if(!FileSystem.exists(childModulePath)) {
-				MakeLog.warning('Path is not found for include "$include"');
+			if (!FileSystem.exists(childModulePath)) {
+				// TODO: pos of meta
+				Context.warning('Path is not found for include "$include"', pos);
 				continue;
 			}
 
 			var cp = Path.join([childModulePath, "make"]);
-			if(FileSystem.exists(cp)) {
+			if (FileSystem.exists(cp)) {
 				PluginInclude.scan(cp);
 				CompileTime.addMakePath(cp);
 			}
 			else {
-				MakeLog.warning('Make directory is not found for module "$include"');
+				// TODO: pos of meta
+				Context.warning('Make directory is not found for module "$include"', pos);
 			}
 
 			childrenExprs.push(macro hxmake.core.CompiledProjectData.createModuleConnection($v{modulePath}, $v{childModulePath}));
 		}
 
 		processMakeLibraries(":lib", cls.meta);
 
-		if(!cls.meta.has(":root")) {
+		if (!cls.meta.has(":root")) {
 			var parentMakeDir = FileSystem.absolutePath(Path.join([modulePath, "..", "make"]));
-			if(FileSystem.exists(parentMakeDir) && FileSystem.isDirectory(parentMakeDir)) {
+			if (FileSystem.exists(parentMakeDir) && FileSystem.isDirectory(parentMakeDir)) {
 				PluginInclude.scan(parentMakeDir);
 				CompileTime.addMakePath(parentMakeDir);
 			}
@@ -67,13 +68,13 @@ class ModuleMacro {
 		};
 
 		fields.push(MacroHelper.makeInitField(macro {
-			var module = @:privateAccess new $tp();
-			if(module.name == null) {
-				module.name = $v{guessModuleName};
-			}
-			module.path = $v{modulePath};
-			hxmake.core.CompiledProjectData.registerModule(module);
-			$b{childrenExprs}
+		var module = @:privateAccess new $tp();
+		if(module.name == null) {
+		module.name = $v{guessModuleName};
+		}
+		module.path = $v{modulePath};
+		hxmake.core.CompiledProjectData.registerModule(module);
+		$b{childrenExprs}
 		}, pos));
 
 		transformConstructor(fields);
@@ -83,11 +84,11 @@ class ModuleMacro {
 
 	static function processMakeLibraries(libraryMeta:String, metaAccess:MetaAccess) {
 		var metaList:Array<MetadataEntry> = metaAccess.extract(libraryMeta);
-		for(meta in metaList) {
-			if(meta.params.length > 0) {
+		for (meta in metaList) {
+			if (meta.params.length > 0) {
 				var libName = exprGetStringConst(meta.params[0]);
 				var libPath = exprGetStringConst(meta.params[1]);
-				if(libName == null) {
+				if (libName == null) {
 					throw '@$libraryMeta first argument need to be String literal';
 				}
 				PluginInclude.include(libName, libPath);
@@ -99,7 +100,7 @@ class ModuleMacro {
 	}
 
 	static function exprGetStringConst(expr:Expr):Null<String> {
-		if(expr == null) {
+		if (expr == null) {
 			return null;
 		}
 		return switch(expr.expr) {
@@ -113,8 +114,8 @@ class ModuleMacro {
 	}
 
 	static function transformConstructor(fields:Array<Field>) {
-		for(field in fields) {
-			if(field.name == "new") {
+		for (field in fields) {
+			if (field.name == "new") {
 				field.name = "__initialize";
 				field.access = [Access.AOverride];
 				// TODO: add more validation at Compile-time
diff --git a/tool/hxmake/tool/AliasScript.hx b/tool/hxmake/tool/AliasScript.hx
@@ -1,14 +1,15 @@
 package hxmake.tool;
 
-import hxmake.cli.MakeLog;
 import haxe.io.Path;
 import haxe.macro.Compiler;
 import hxmake.cli.CL;
+import hxmake.cli.MakeLog;
 import hxmake.utils.Haxelib;
 
 class AliasScript {
 	public static function main() {
-		MakeLog.initialize(Sys.args());
+		var args = Sys.args();
+		MakeLog.initialize(args.indexOf("--silent") >= 0, args.indexOf("--verbose") >= 0);
 		var library = Compiler.getDefine("library");
 		var toolPath = Haxelib.libPath(library, true);
 		Sys.exit(CL.command("neko", [Path.join([toolPath, "run.n"])].concat(Sys.args())));
diff --git a/tool/hxmake/tool/MakeRunner.hx b/tool/hxmake/tool/MakeRunner.hx
@@ -1,11 +1,11 @@
 package hxmake.tool;
 
+import haxe.io.Path;
 import hxmake.cli.CL;
-import hxmake.utils.HaxeTarget;
-import hxmake.utils.Hxml;
 import hxmake.utils.Haxe;
 import hxmake.utils.Haxelib;
-import haxe.io.Path;
+import hxmake.utils.HaxeTarget;
+import hxmake.utils.Hxml;
 
 @:final
 class MakeRunner {
@@ -26,8 +26,11 @@ class MakeRunner {
 		hxml.libraries = [];
 		hxml.classPath.push(libPath);
 		hxml.defines.push("hxmake");
+		if (builtInArguments.indexOf("--macrolog") >= 0) {
+			hxml.defines.push("hxmake_macrolog");
+		}
 
-		if(isCompiler) {
+		if (isCompiler) {
 			hxml.target = HaxeTarget.Interp;
 		}
 		else {
@@ -46,7 +49,7 @@ class MakeRunner {
 		hxml.showTimes = builtInArguments.indexOf("--times") >= 0;
 
 		var result = Haxe.compile(hxml);
-		if(!result || isCompiler) {
+		if (!result || isCompiler) {
 			return result;
 		}
 
@@ -55,8 +58,8 @@ class MakeRunner {
 
 	static function toLiteralsArrayString(values:Array<String>):String {
 		var args = [];
-		if(values != null) {
-			for(v in values) {
+		if (values != null) {
+			for (v in values) {
 				args.push('"$v"');
 			}
 		}
diff --git a/tool/hxmake/tool/RunScript.hx b/tool/hxmake/tool/RunScript.hx
@@ -1,35 +1,35 @@
 package hxmake.tool;
 
-import hxmake.cli.MakeLog;
 import haxe.Timer;
+import hxmake.cli.MakeLog;
 
 class RunScript {
 
 	public static function main() {
 		var args = popRunCwd(Sys.args());
 		var success = false;
 
-		MakeLog.initialize(args);
+		MakeLog.initialize(args.indexOf("--silent") >= 0, args.indexOf("--verbose") >= 0);
 
 		measure(function() {
 			success = run(args);
 		}, args.indexOf("--times") < 0);
 
-		if(!success) {
+		if (!success) {
 			MakeLog.error("hxmake FAILED");
 			Sys.exit(-1);
 		}
 	}
 
 	static function run(args:Array<String>):Bool {
-		if(args.indexOf("_") >= 0) {
+		if (args.indexOf("_") >= 0) {
 			return Installer.run("hxmake");
 		}
 		return MakeRunner.make(Sys.getCwd(), args);
 	}
 
-	static function measure(func:Void->Void, bypass:Bool = false) {
-		if(bypass) {
+	static function measure(func:Void -> Void, bypass:Bool = false) {
+		if (bypass) {
 			func();
 			return;
 		}
@@ -43,7 +43,7 @@ class RunScript {
 	static function popRunCwd(args:Array<String>):Array<String> {
 		var result = args.copy();
 		var env = Sys.getEnv("HAXELIB_RUN");
-		if(env != null && env.length > 0 && Std.parseInt(env) != 0) {
+		if (env != null && env.length > 0 && Std.parseInt(env) != 0) {
 			Sys.setCwd(result.pop());
 		}
 		return result;

Original file line number	Diff line number	Diff line change
`@@ -14,4 +14,10 @@ class CompileTime {`
`14`	`14`	`Compiler.addClassPath(makePath);`
`15`	`15`	`Compiler.include("", true, null, [makePath]);`
`16`	`16`	`}`
	`17`	`+`
	`18`	`+ public static function log(message:String) {`
	`19`	`+ #if hxmake_macrolog`
	`20`	`+ Sys.println('[MACRO] $message');`
	`21`	`+ #end`
	`22`	`+ }`
`17`	`23`	`}`