Release 0.15.3

Update README.md

README.md

@@ -303,7 +303,7 @@ abstract Member from Field to Field {
 
 Most of the API should be self-explaining. The `isBound` property is a bad name to convey the concept that a field can be either `inline` (`true`) or `dynamic` (`false`) or neither (`null`). Equally, `isPublic` is nullable which means that normally defaults to `private`.
 
-The `publish` method will make a field `public` if it is not `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.
+The `publish` method will make a field `public` if it is not explicitly marked as `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.
 
 The `extractMeta` method will "peel of" the first tag with a given `name` - if available. Note that the tag will be removed from the member.
 
@@ -391,7 +391,7 @@ The `init` method is the swiss army knife of initializing fields. The `options.p
 
 #### Setter Bypass
 
-It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will by bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.
+It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will be bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.
 
 Setter bypass also causes the field to gain an `@:isVar`. And currently, with `-dce full`, additional code will be generated to avoid the field to be eliminated.
 

haxelib.json

@@ -11,8 +11,8 @@
 	"contributors": [
 		"back2dos"
 	],
-	"releasenote": "Add way to get constructor args.",
-	"version": "0.14.2",
+	"releasenote": "Fixes issues caused by private types.",
+	"version": "0.15.3",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

src/tink/macro/Exprs.hx

@@ -319,9 +319,8 @@ class Exprs {
           expr = [EVars(locals).at(expr.pos), expr].toMBlock(expr.pos);
         Success(Context.typeof(expr));
       }
-      catch (e:Error) {
-        var m:Dynamic = e.message;
-        e.pos.makeFailure(m);
+      catch (e:haxe.macro.Error) {
+        e.pos.makeFailure(e.message);
       }
       catch (e:Dynamic) {
         expr.pos.makeFailure(e);

src/tink/macro/Positions.hx

@@ -12,7 +12,7 @@ class Positions {
     return 
       switch outcome {
         case Success(d): d;
-        case Failure(f): sanitize(pos).error(f);
+        case Failure(f): pos.error(f);
       }
   
   static public function makeBlankType(pos:Position):ComplexType 
@@ -32,7 +32,17 @@ class Positions {
 
 
   static public function error(pos:Position, error:Dynamic):Dynamic 
-    return errorFunc(sanitize(pos), Std.string(error));
+    return 
+      switch Std.instance(error, tink.core.Error) {
+        case null: errorFunc(sanitize(pos), Std.string(error));
+        case error: 
+          errorFunc(
+            error.pos, 
+            error.message + 
+              if (pos == null) ''
+              else ' (referenced from ' + Std.string(pos).substr(5)
+          );
+      }
   
   static function contextError(pos:Position, error:String):Dynamic 
     return Context.fatalError(error, pos);

src/tink/macro/Sisyphus.hx

@@ -17,6 +17,7 @@ class Sisyphus {
         case AccCall: getOrSet;
         case AccInline: "default";
         case AccRequire(_, _): "default";
+        default: throw "not implemented";
       }
     }
     if (cf.params.length == 0) {
@@ -52,12 +53,18 @@ class Sisyphus {
     }
   }
 
-  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return
+
+  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return {
+    inline function direct()
+      return Types.toComplex(type, { direct: true });
     switch (type) {
       case null:
         null;
-      case TMono(_.get() => t):
-        t == null ? Types.toComplex(type, { direct: true }) : toComplexType(t);
+      case TEnum(_.get().isPrivate => true, _): direct();
+      case TInst(_.get().isPrivate => true, _): direct();
+      case TType(_.get().isPrivate => true, _): direct();
+      case TAbstract(_.get().isPrivate => true, _): direct();
+      case TMono(_): direct();
       case TEnum(_.get() => baseType, params):
         TPath(toTypePath(baseType, params));
       case TInst(_.get() => classType, params):
@@ -92,7 +99,7 @@ class Sisyphus {
       default:
         throw "Invalid type";
     }
-
+  }
   static function toTypePath(baseType : BaseType, params : Array<Type>) : TypePath return {
     var module = baseType.module;
     {
@@ -102,4 +109,4 @@ class Sisyphus {
       params: [ for (t in params) TPType(toComplexType(t)) ],
     }
   }
-}
+}