Make TypeMap work exacly with anons.

src/tink/macro/Sisyphus.hx

@@ -138,7 +138,7 @@ class Sisyphus {
     }
   }
 
-  static function exactBase<T:BaseType>(r:haxe.macro.Type.Ref<T>, params:Array<Type>) {
+  static function exactBase<T:BaseType>(r:Ref<T>, params:Array<Type>) {
     var t = r.get();
     var isMain = !t.isPrivate && switch t.pack {
       case []: t.module == t.name || t.module == 'StdTypes';
@@ -197,4 +197,29 @@ class Sisyphus {
       case TLazy(f): toExactString(f());
     }
 
+    static function eager(t:Type)
+      return switch t {
+        case TLazy(f): eager(f());
+        default: t;
+      }
+
+    static public function compare(t1:Type, t2:Type, ?follow:Bool = true) {
+      if (follow) {
+        t1 = t1.reduce();
+        t2 = t2.reduce();
+      }
+      else {
+        t1 = eager(t1);
+        t2 = eager(t2);
+      }
+
+      return switch t1.getIndex() - t2.getIndex() {
+        case 0:
+          switch Reflect.compare(t1.toString(), t2.toString()) {
+            case 0: Reflect.compare(t1.toExactString(), t2.toExactString());
+            case v: v;
+          }
+        case v: v;
+      }
+    }
 }

src/tink/macro/Types.hx

@@ -10,6 +10,8 @@ using haxe.macro.Tools;
 using tink.MacroApi;
 using tink.CoreApi;
 
+import haxe.macro.Type.Ref;
+
 class Types {
 
   static public function definedType(typeName:String)
@@ -355,18 +357,8 @@ class Types {
           throw 'assert';
       }
 
-  static public function compare(t1:Type, t2:Type, ?follow:Bool = true) {
+  static public function compare(t1:Type, t2:Type, ?follow:Bool = true)
-    if (follow) {
+    return Sisyphus.compare(t1, t2, follow);
-      t1 = t1.reduce();
-      t2 = t2.reduce();
-    }
-
-    return switch t1.getIndex() - t2.getIndex() {
-      case 0:
-        Reflect.compare(t1.toString(), t2.toString());//much to my surprise, this actually seems to work (at least with 3.4)
-      case v: v;
-    }
-  }
 
   static var SUGGESTIONS = ~/ \(Suggestions?: .*\)$/;
 

tests/ExactStrings.hx

@@ -1,4 +1,3 @@
-import haxe.macro.Context;
 import haxe.macro.Context.typeof;
 using tink.MacroApi;
 
@@ -12,6 +11,8 @@ class ExactStrings extends Base {
     expect('Dummy.Private', macro Dummy.p);
     expect('nested.Dummy.Private', macro nested.Dummy.p);
     expect('{ @foo var x:Int; }', macro (null:{@foo var x:Int;}));
+    expect('{ @foo @bar var x:Int; }', macro (null:{@foo @bar var x:Int;}));
+    expect('{ @bar @foo var x:Int; }', macro (null:{@bar @foo var x:Int;}));// not 100% sure this is always the best choice, but let's roll with it
     expect('{ @bar var x:Int; }', macro (null:{@bar var x:Int;}));
     expect('{ var x:Int; var y:Int; }', macro (null:{x:Int,y:Int}));
     expect('{ var x:Int; var y:Int; }', macro (null:{y:Int,x:Int}));

tests/TypeMapTest.hx

@@ -11,6 +11,8 @@ class TypeMapTest extends TestCase {
     var t = new TypeMap();
     var t1 = (macro [{ foo: [{ bar: '5' }]}]).typeof().sure();
     var t2 = (macro [{ foo: [{ bar: 5 }]}]).typeof().sure();
+    var t3 = (macro [{ foo: [{ bar: 5 }]}]).typeof().sure();
+    var t4 = (macro [{ foo: [({ bar: 5 }:{ @foo var bar:Int; })]}]).typeof().sure();
 
     t.set(t1, 0);
     assertEquals(Lambda.count(t), 1);
@@ -19,7 +21,10 @@ class TypeMapTest extends TestCase {
     t.set(t1, 2);
     assertEquals(Lambda.count(t), 2);
     t.set(t2, 3);
+    t.set(t3, 3);
     assertEquals(Lambda.count(t), 2);
+    t.set(t4, 4);
+    assertEquals(Lambda.count(t), 3);
 
     assertEquals(t.get(t1), 2);
     assertEquals(t.get(t2), 3);

tests/Types.hx

@@ -21,7 +21,6 @@ class Types extends Base {
     assertFalse(o.isSuccess());
 
   function testIs() {
-    
     assertSuccess(resolve('Int').isSubTypeOf(resolve('Float')));
     assertFailure(resolve('Float').isSubTypeOf(resolve('Int')));
   }