diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 87be841..f0be025 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,8 +15,10 @@ jobs:
         haxe-version:
           - stable
           - nightly
-        target: 
+        target:
           - interp
+          - interp -D function_sugar
+          - interp -D deprecated_function_sugar
           - neko
           - node
           - python
@@ -26,7 +28,7 @@ jobs:
     steps:
     - name: Check out repo
       uses: actions/checkout@v2
-    
+
     - name: Get yarn cache directory path
       id: yarn-cache-dir-path
       run: echo "::set-output name=dir::$(yarn cache dir)"
@@ -38,22 +40,22 @@ jobs:
         key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
         restore-keys: |
           ${{ runner.os }}-yarn-
-        
+
     - name: Cache Haxe
       uses: actions/cache@v1
       with:
         path: ${{ startsWith(runner.os, 'windows') && '%AppData%' || '~/haxe' }}
         key: ${{ runner.os }}-haxe
-        
+
     - name: Install Lix
       uses: lix-pm/setup-lix@master
-      
+
     - name: Install Haxe
       run: lix install haxe ${{ matrix.haxe-version }}
-    
+
     - name: Install Haxe Libraries
       run: lix download
-      
+
     - name: Run Test
       run: lix run travix ${{ matrix.target }}
 
@@ -61,11 +63,11 @@ jobs:
     runs-on: ubuntu-latest
     needs: test
     if: startsWith(github.ref, 'refs/tags/') # consider using the "release" event. see: https://docs.github.com/en/actions/reference/events-that-trigger-workflows#release
-    
+
     steps:
     - name: Check out repo
       uses: actions/checkout@v2
-    
+
     - name: Get yarn cache directory path
       id: yarn-cache-dir-path
       run: echo "::set-output name=dir::$(yarn cache dir)"
@@ -77,24 +79,23 @@ jobs:
         key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
         restore-keys: |
           ${{ runner.os }}-yarn-
-        
+
     - name: Cache Haxe
       uses: actions/cache@v1
       with:
         path: ${{ startsWith(runner.os, 'windows') && '%AppData%' || '~/haxe' }}
         key: ${{ runner.os }}-haxe
-        
+
     - name: Install Lix
       uses: lix-pm/setup-lix@master
-      
+
     - name: Install Haxe
       run: lix install haxe stable
-    
+
     - name: Install Haxe Libraries
       run: lix download
-      
+
     - name: Release to Haxelib
       run: lix run travix release
       env:
         HAXELIB_AUTH: ${{ secrets.HAXELIB_AUTH }}
-    
\ No newline at end of file
diff --git a/.haxerc b/.haxerc
index f8137ff..ef43126 100644
--- a/.haxerc
+++ b/.haxerc
@@ -1,4 +1,4 @@
 {
-  "version": "4.2.0",
+  "version": "4.3.6",
   "resolveLibs": "scoped"
 }
\ No newline at end of file
diff --git a/README.md b/README.md
index 82d578e..b84099d 100644
--- a/README.md
+++ b/README.md
@@ -503,7 +503,7 @@ hxx('
 
 ## Implicit function syntax
 
-For attributes that are functions with 0 or 1 argument, you may write the function body directly:
+With `using tink.hxx.FunctionSugar;` (which can be placed in [`import.hx`](https://haxe.org/manual/type-system-import-defaults.html)), for attributes that are functions with 0 or 1 argument, you may write the function body directly:
 
 ```haxe
 hxx('
@@ -514,6 +514,14 @@ hxx('
 
 Note that if there's exactly one argument, it will be called "event".
 
+Up until version 0.25 this has been a standard feature, but it has been relegated to an opt-in (via `using`) for a few reasons:
+
+1. some users - especially new comers - consider it confusing rather than convenient (that is left for you to judge)
+2. it's hard to implement in a way that works well with IDE services (this may change in the future though)
+3. it makes code harder to port to JSX, should the need arise
+
+If you have exisiting code relying on this feature but wish to migrate away from it, you may use `using tink.hxx.DeprecatedFunctionSyntax;` instead, which will also activate the feature, but produces warnings anywhere it is used.
+
 ## Whitespace
 
 The treatment of whitespace depends on whether the generated structure even has any notion of whitespace or not. The default HXX flavor uses the JSX style whitespace explained below.
@@ -548,7 +556,7 @@ Example:
 
 ```
 
-The first version will retain the white space between the two spans, the second one will not.  
+The first version will retain the white space between the two spans, the second one will not.
 
 To enforce a whitspace, `${' '}` can be used, e.g.:
 
diff --git a/haxe_libraries/tink_anon.hxml b/haxe_libraries/tink_anon.hxml
index e885a54..6046e27 100644
--- a/haxe_libraries/tink_anon.hxml
+++ b/haxe_libraries/tink_anon.hxml
@@ -1,4 +1,4 @@
-# @install: lix --silent download "gh://github.com/haxetink/tink_anon#ef441a73a41f9ae4ca0f060035ff2c188618df4c" into tink_anon/0.7.0/github/ef441a73a41f9ae4ca0f060035ff2c188618df4c
+# @install: lix --silent download "gh://github.com/haxetink/tink_anon#0277e6e3f97a7878f1aa9aeeccc4b7be0e9c82bc" into tink_anon/0.7.0/github/0277e6e3f97a7878f1aa9aeeccc4b7be0e9c82bc
 -lib tink_macro
--cp ${HAXE_LIBCACHE}/tink_anon/0.7.0/github/ef441a73a41f9ae4ca0f060035ff2c188618df4c/src
+-cp ${HAXE_LIBCACHE}/tink_anon/0.7.0/github/0277e6e3f97a7878f1aa9aeeccc4b7be0e9c82bc/src
 -D tink_anon=0.7.0
\ No newline at end of file
diff --git a/haxe_libraries/tink_core.hxml b/haxe_libraries/tink_core.hxml
index 43cf59b..37d612f 100644
--- a/haxe_libraries/tink_core.hxml
+++ b/haxe_libraries/tink_core.hxml
@@ -1,3 +1,3 @@
-# @install: lix --silent download "gh://github.com/haxetink/tink_core#d74b0e03d7f9efcf2c2b73fecd99d240dd6d57ff" into tink_core/2.0.2/github/d74b0e03d7f9efcf2c2b73fecd99d240dd6d57ff
--cp ${HAXE_LIBCACHE}/tink_core/2.0.2/github/d74b0e03d7f9efcf2c2b73fecd99d240dd6d57ff/src
+# @install: lix --silent download "gh://github.com/haxetink/tink_core#f500203b657859bfde36c49e54f95a0b1fc2b165" into tink_core/2.0.2/github/f500203b657859bfde36c49e54f95a0b1fc2b165
+-cp ${HAXE_LIBCACHE}/tink_core/2.0.2/github/f500203b657859bfde36c49e54f95a0b1fc2b165/src
 -D tink_core=2.0.2
\ No newline at end of file
diff --git a/src/tink/hxx/DeprecatedFunctionSugar.hx b/src/tink/hxx/DeprecatedFunctionSugar.hx
new file mode 100644
index 0000000..c961e82
--- /dev/null
+++ b/src/tink/hxx/DeprecatedFunctionSugar.hx
@@ -0,0 +1,3 @@
+package tink.hxx;
+
+extern class DeprecatedFunctionSugar {}
\ No newline at end of file
diff --git a/src/tink/hxx/Expression.hx b/src/tink/hxx/Expression.hx
new file mode 100644
index 0000000..8854126
--- /dev/null
+++ b/src/tink/hxx/Expression.hx
@@ -0,0 +1,5 @@
+package tink.hxx;
+
+@:callable @:transitive
+abstract Expression<T>(()->T) from ()->T to ()->T {
+}
\ No newline at end of file
diff --git a/src/tink/hxx/FunctionSugar.hx b/src/tink/hxx/FunctionSugar.hx
new file mode 100644
index 0000000..a4a8662
--- /dev/null
+++ b/src/tink/hxx/FunctionSugar.hx
@@ -0,0 +1,3 @@
+package tink.hxx;
+
+extern class FunctionSugar {}
\ No newline at end of file
diff --git a/src/tink/hxx/Generator.hx b/src/tink/hxx/Generator.hx
index 6199570..6730527 100644
--- a/src/tink/hxx/Generator.hx
+++ b/src/tink/hxx/Generator.hx
@@ -19,14 +19,7 @@ class Generator {
   dynamic function adjustFormattingPos(pos:Position)
     return pos;
 
-  public var defaults(default, null):Lazy<Array<Named<Position->Tag>>>;
-
-  public function new(?defaults) {
-    this.defaults = switch defaults {
-      case null: [];
-      case v: v;
-    }
-
+  public function new() {
     var shift = {
       var pos = (macro null).pos;
       Context.getPosInfos(('foo'.formatString(pos):Expr).pos).min - Context.getPosInfos(pos).min;
@@ -51,9 +44,10 @@ class Generator {
     }
 
   function tag(n:Node, tag:Tag, pos:Position) {
+    var paramatrized = tag.parametrized();
 
     var aliases = tag.args.aliases,
-        children = tag.args.children,
+        children:Type = paramatrized.children,//tag.args.children,
         fields = tag.args.fields,
         fieldsType = tag.args.fieldsType,
         childrenAttribute = tag.args.childrenAttribute;
@@ -129,7 +123,7 @@ class Generator {
       case l:
 
         function get()
-          return applyCustomRules(tag.args.children, this.childList.bind(l, _));
+          return applyCustomRules(children, this.childList.bind(l, _));
 
         switch childrenAttribute {
           case null:
@@ -151,7 +145,6 @@ class Generator {
 
     args.unshift(
       compute(function () {
-        var paramatrized = tag.parametrized();
         var attrType = paramatrized.fieldsType;
 
         return mergeParts(
@@ -178,6 +171,13 @@ class Generator {
             },
             duplicateField: function (name) return 'duplicate attribute $name',
             missingField: function (f) return 'missing attribute ${f.name}',//TODO: might be nice to put type here
+          },
+          (owner, field) -> {
+            var e = owner.field(field.name, owner.pos);
+            switch field.type.get() {
+              case None: e;
+              case Some(t): applyCustomRules(t, _ -> e);
+            }
           }
         );
       })
@@ -189,8 +189,8 @@ class Generator {
     return invoke({ value: tag.realPath, pos: tagName.pos }, tag.create, args, tagName.pos);
   }
 
-  function later(fn:Void->Expr)
-    return withTags.bind(localTags, fn).bounce();
+  inline function later(fn:Void->Expr)
+    return fn.bounce();
 
   function makePart(name:StringAt, value:Expr, ?quotes):Part
     return {
@@ -213,16 +213,14 @@ class Generator {
         }
     };
 
-  function applyCustomRules(t, getValue:Type->Expr) {
-    var transform = getTransform(t);
-    t = transform.reduced.or(t);
-    var e = getValue(t);
-    return switch transform.postprocessor {
-      case PTyped(f): f.bind(e).bounce();
-      case PUntyped(f): f(e);
-      default: e;
+  function applyCustomRules(t:Type, getValue:Type->Expr)
+    return switch t.reduce() {
+      case TAbstract(_.toString() => 'tink.hxx.Expression', [t]):
+        var ret = applyCustomRules(t, getValue);
+        ret = macro @:pos(ret.pos) function () return $ret;
+      default:
+        getTransform(t)(getValue(t));
     }
-  }
 
   function invoke(name:StringAt, create:TagCreate, args:Array<Expr>, pos:Position)
     return
@@ -251,7 +249,6 @@ class Generator {
     return !Context.unify(Context.getType('Array'), t.reduce());
 
   function complexAttribute(n:Node):Part {
-    var localTags = localTags;
     return {
       name: n.name.value,
       pos: n.name.pos,
@@ -298,32 +295,11 @@ class Generator {
                   return this.childList(n.children, ret);
 
                 var body =
-                  if (splat) {
-                    var tags = switch requiredArgs[0].t.getFields() {
-                      case Success(fields):
-                        var ret =
-                          #if haxe4
-                            localTags.copy();
-                          #else
-                            [for (t in localTags.keys()) t => localTags[t]];
-                          #end
-
-                        for (c in fields)
-                          ret[c.name] = Tag.declaration.bind(c.name, _, c.type, c.params);
-
-                        ret;
-                      default:
-                        localTags;
-                    }
-
+                  if (splat) 
                     macro @:pos(n.name.pos) {
                       tink.Anon.splat(__data__);
-                      return ${
-                        if (tags != localTags) withTags(tags, getBody)
-                        else later(withTags.bind(tags, getBody))
-                      };
+                      return ${later(getBody)};
                     }
-                  }
                   else getBody();
                 body.func(args).asExpr();
               default:
@@ -352,6 +328,7 @@ class Generator {
                   throw 'assert';
               }
             }
+        else if (c == null || c.value.length == 0) macro ([]:$ct);
         else macro {
           var __r = [];
           if (false) (__r:$ct);
@@ -501,42 +478,30 @@ class Generator {
   }
 
   function node(n, pos)
-    return tag(n, getTag(n.name), pos);
-
-  function getTag(name:StringAt):Tag
-    return Tag.resolve(localTags, name).sure();
-
-  var localTags:Map<String, Position->Tag>;
+    return tag(n, Tag.resolve(n.name), pos);
 
   var postProcess:Expr->Expr = function (e) return e;
 
-  function withTags<T>(tags, f:Void->T) {
-    #if tink_syntaxhub var lastFn = postProcess; #end
-
-    var last = localTags;
-    return tink.core.Error.tryFinally(
-      function () {
-        localTags = tags;
-        #if tink_syntaxhub
-        postProcess = switch tink.SyntaxHub.exprLevel.appliedTo(new ClassBuilder()) {
-          case Some(f): f;
-          case None: function (e) return e;
-        }
-        #end
-        return f();
-      },
-      function () {
-        localTags = last;
-        #if tink_syntaxhub postProcess = lastFn; #end
-      }
-    );
-  }
-
   public function createContext():GeneratorContext {
-    var tags = Tag.getAllInScope(defaults);
     return {
-      isVoid: function (name) return Tag.resolve(tags, name).match(Success({ isVoid: true })),
-      generateRoot: function (root:Children) return withTags(tags, function () return children(root)),
+      isVoid: function (name) return false,
+      generateRoot: function (root:Children) {
+        #if tink_syntaxhub 
+        var lastFn = postProcess;
+        return tink.core.Error.tryFinally(
+          function () {
+            postProcess = switch tink.SyntaxHub.exprLevel.appliedTo(new ClassBuilder()) {
+              case Some(f): f;
+              case None: function (e) return e;
+            }
+            return children(root);
+          },
+          function () postProcess = lastFn
+        );
+        #else
+        return children(root);
+        #end
+      }
     }
   }
 
diff --git a/src/tink/hxx/Helpers.hx b/src/tink/hxx/Helpers.hx
index 1b0f83d..4e4c7ed 100644
--- a/src/tink/hxx/Helpers.hx
+++ b/src/tink/hxx/Helpers.hx
@@ -125,8 +125,25 @@ class Helpers {
     return s.substring(pos, max);
   }
 
+  static var measured = false;
   static public function functionSugar(value:Expr, t:Type) {
 
+    var mode = Off;
+
+    for (c in Context.getLocalUsing()) // TODO: doing this here might be rather expensive
+      switch c.toString() {
+        case 'tink.hxx.FunctionSugar':
+          mode = On;
+          break;
+        case 'tink.hxx.DeprecatedFunctionSugar':
+          mode = Deprecated;
+          break;
+        default:
+      }
+
+    if (mode == Off)
+      return value;
+
     while (true) switch value {
       case macro ($v): value = v;
       default: break;
@@ -146,6 +163,9 @@ class Helpers {
             case TDynamic(null):
               value.reject('Cannot use `Dynamic` as callback');
             case found:
+              if (mode == Deprecated)
+                e.pos.warning('Automatic function wrapping is deprecated');
+
               if (Context.unify(found, t)) Context.storeTypedExpr(f.expr);
               else if (typed.hasThis()) macro @:pos(e.pos) (function () return $e)();
               else Context.storeTypedExpr(typed);
@@ -189,9 +209,9 @@ class Helpers {
     }
   }
 
-  static var transformers = new Map<String, Option<Transformer>>();
+  static var transformers = new Map<String, Option<Expr->Expr>>();
 
-  static function getCustomTransformer<T:BaseType>(r:haxe.macro.Type.Ref<T>):Option<Transformer> {
+  static function getCustomTransformer<T:BaseType>(r:haxe.macro.Type.Ref<T>) {
     var id = r.toString();
     return switch transformers[id] {
       case null:
@@ -199,31 +219,19 @@ class Helpers {
           case []: None;
           case [{ params: params }]:
 
-            var basicType = null,
-                transform = null;
+            var transform = null;
 
             for (p in params)
               switch p {
-                case macro basicType = $e: basicType = e;
                 case macro transform = $e: transform = e;
                 case macro $e = $_: e.reject('unknown option ${e.toString()}');
                 default: p.reject('should be `<name> = <option>`');
               }
 
-            Some({
-              reduceType: switch basicType {
-                case null: function (t) return t;
-                case v: function (t:Type) {
-                  var ct = t.toComplex();
-                  return basicType.substitute({ _: macro (null: $ct) }).typeof().sure();
-                }
-              },
-              postprocessor:
-                switch transform {
-                  case null: PNone;
-                  case pattern: PUntyped(function (e) return pattern.substitute({ _: e }));
-                }
-            });
+            switch transform {
+              case null: None;
+              case v: Some(e -> v.substitute({ '_' : e }));
+            }
 
           case v: v[1].pos.error('only one @:fromHxx rule allowed per type');
         }
@@ -231,71 +239,27 @@ class Helpers {
     }
   }
 
-  static public function setCustomTransformer(typeID:String, transformer:Transformer)
-    transformers[typeID] = Some(transformer);
-
-  static public function getTransform(t:Type):Transform
+  static public function getTransform(t:Type):Expr->Expr
     return
       switch t {
-        case TAbstract(getCustomTransformer(_) => Some(r), _)
-           | TInst(getCustomTransformer(_) => Some(r), _)
-           | TEnum(getCustomTransformer(_) => Some(r), _)
-           | TType(getCustomTransformer(_) => Some(r), _):
-
-          var postprocessor:Postprocessor<Expr->Expr> = switch r.postprocessor {
-            case PTyped(fn): PTyped(fn.bind(t));
-            case PNone: PNone;
-            case PUntyped(fn): PUntyped(fn);
-          }
+        case TAbstract(getCustomTransformer(_) => Some(f), _)
+           | TInst(getCustomTransformer(_) => Some(f), _)
+           | TEnum(getCustomTransformer(_) => Some(f), _)
+           | TType(getCustomTransformer(_) => Some(f), _):
 
-          switch r.reduceType(t) {
-            case _ == t => true:
-              {
-                reduced: None,
-                postprocessor: postprocessor,
-              }
-            case reducedType:
-              var inner = getTransform(reducedType);
-              {
-                reduced: switch inner.reduced {
-                  case None: Some(reducedType);
-                  case v: v;
-                },
-                postprocessor: switch [inner.postprocessor, postprocessor] {
-                  case [PNone, v] | [v, PNone]: v;
-                  case [PUntyped(i), PUntyped(o)]:
-                    PUntyped(function (e) return o(i(e)));
-                  case [PUntyped(i) | PTyped(i), PUntyped(o) | PTyped(o)]:
-                    PTyped(function (e) return o(i(e)));
-                }
-              }
-          }
+          f;
         case TType(_, _) | TLazy(_) | TAbstract(_.get() => { pack: [], name: 'Null' }, _):
           getTransform(t.reduce(true));
         default:
-          NOOP;
+          noop;
       }
 
-  static var NOOP:Transform = {
-    reduced: None,
-    postprocessor: PNone,
-  }
-
-}
-
-typedef Transformer = {
-  function reduceType(t:Type):Type;
-  var postprocessor(default, null):Postprocessor<Type->Expr->Expr>;
-}
-
-typedef Transform = {
-  var reduced(default, never):Option<Type>;
-  var postprocessor(default, never):Postprocessor<Expr->Expr>;
+  static function noop(e:Expr) return e;
 }
 
-enum Postprocessor<T> {
-  PNone;
-  PUntyped(f:Expr->Expr);
-  PTyped(f:T);
+@:enum private abstract FunctionSugarMode(Int) {
+  var Off = 0;
+  var On = 1;
+  var Deprecated = 2;
 }
 #end
\ No newline at end of file
diff --git a/src/tink/hxx/Parser.hx b/src/tink/hxx/Parser.hx
index 5359e73..cd66b07 100644
--- a/src/tink/hxx/Parser.hx
+++ b/src/tink/hxx/Parser.hx
@@ -21,7 +21,6 @@ typedef ParserConfig = {
   ?fragment:String,
   ?defaultSwitchTarget:Expr,
   ?noControlStructures:Bool,
-  ?isVoid:StringAt->Bool,
   //?interceptTag:String->Option<StringAt->Expr>, <--- consider adding this back
 }
 
@@ -69,7 +68,6 @@ class Parser extends ParserBase<Position, haxe.macro.Error> {
 
   var fileName:String;
   var config:ParserConfig;
-  var isVoid:StringAt->Bool;
   var createParser:ParserSource->Parser;
   var treatNested:Children->Expr;
 
@@ -80,14 +78,6 @@ class Parser extends ParserBase<Position, haxe.macro.Error> {
 
     super(setup.source, Reporter.expr(this.fileName = setup.fileName), setup.offset);
 
-    function get<T>(o:{ var isVoid(default, null):T; })
-      return o.isVoid;
-
-    this.isVoid = switch get(config) {
-      case null: function (_) return false;
-      case v: v;
-    }
-
     this.treatNested = config.treatNested;
   }
 
@@ -231,11 +221,6 @@ class Parser extends ParserBase<Position, haxe.macro.Error> {
       var r = parseAttributes();
       hasChildren = !r.selfClosing;
       attrs = r.attributes;
-      if (isVoid(name)) {
-        if (!r.selfClosing)
-          name.pos.warning('Consider using a self-closing <${name.value}/> instead of void syntax for better portability.');
-        hasChildren = false;
-      }
     }
 
     return CNode({
@@ -391,10 +376,7 @@ class Parser extends ParserBase<Position, haxe.macro.Error> {
                 tagName() + expectHere('>');
             if (found != closing)
               die(
-                if (isVoid(withPos(found)))
-                  '</$found> is illegal because <$found> is a void tag'
-                else
-                  'found </$found> but expected </$closing>',
+                'found </$found> but expected </$closing>',
                 found.start...found.end
               );
             return result(found.start - 2);
diff --git a/src/tink/hxx/Tag.hx b/src/tink/hxx/Tag.hx
index cdbe7e9..bc77006 100644
--- a/src/tink/hxx/Tag.hx
+++ b/src/tink/hxx/Tag.hx
@@ -21,6 +21,7 @@ using StringTools;
   public var hxxMeta(default, null):Map<String, Type>;
 
   public var parametrized(default, null):Void->{
+    var children(default, never):Type;
     var fieldsType(default, null):ComplexType;
     var requiredFields(default, null):RequireFields;
   }
@@ -28,88 +29,58 @@ using StringTools;
   static function startsCapital(s:String)
     return s.charAt(0).toUpperCase() == s.charAt(0);
 
-  static public function resolve(localTags:Map<String, Position->Tag>, name:StringAt):Outcome<Tag, Error>
-    return switch localTags[name.value] {
-      case null:
-        var found = Context.getLocalVars()[name.value];
+  static final cache = new Map();
 
-        if (found == null) {
-          var path = name.value.split('.');
-          if (path.length > 1 || startsCapital(path[path.length - 1]))
-            found = Context.typeof(name.value.resolve(name.pos));
-        }
+  static public function resolve(name:StringAt):Tag {
+    var te = Context.typeExpr(name.value.resolve(name.pos));
 
-        if (found == null)
-          name.pos.makeFailure('unknown tag <${name.value}>');
-        else
-          Success((localTags[name.value] = declaration.bind(name.value, _, found, []))(name.pos));
-      case get: Success(get(name.pos));
-    }
+    var params = [],
+        t = te.t;
 
-  static public function getAllInScope(defaults:Lazy<Array<Named<Position->Tag>>>) {
-    var localTags = new Map();
-    function add(name:String, type, params)
-      if (name.charAt(0) != '_')//seems reasonable
-        localTags[name] = {
-          var ret = null;
-          function (pos) {//seems I've reimplemented `tink.core.Lazy` here for some reason
-            if (ret == null)
-              ret = declaration(name, pos, type, params);
-            return ret;
+    var key = switch te.expr {
+      case TLocal(v): 'local_${v.id}';// I hope this is unique
+      case TTypeExpr(e):
+        'type_' + switch e {
+          case TTypeDecl(d): d.get().type.toString();
+          case TEnumDecl(_.toString() => s)
+            | TAbstract(_.toString() => s)
+            | TClassDecl(_.toString() => s): s;
+        }
+      case TField(_, fa):
+        function id(cl:haxe.macro.Type.Ref<ClassType>, params:Array<Type>)
+          return cl.toString() + switch params {
+            case []: '';
+            case v: '<' + [for (t in v) t.toString()].join(',') +  '>';
           }
+        switch fa {
+          case FEnum(e, f):
+            params = f.params;
+            t = f.type;
+            'enum_${e.toString()}.${f.name}';
+          case FStatic(c, _.get() => f):
+            params = f.params;
+            t = f.type;
+            'static_${c.toString()}.${f.name}';
+          case FAnon(_) | FDynamic(_):
+            te.t.toString();
+          case FClosure(owner, _.get() => f):
+            params = f.params;
+            t = f.type;
+            'inst_${id(owner.c, owner.params)}.${f.name}';
+          case FInstance(cl, params, f):
+            'inst_${id(cl, params)}.${f.toString()}';
         }
-    var vars = Context.getLocalVars();
-    for (name in vars.keys())
-      add(name, vars[name], []);
-
-    switch Context.getLocalType() {
-      case null:
-      case v = TInst(_.get().statics.get() => statics, _):
-
-        var fields = [for (f in v.getFields(false).sure()) f.name => f],
-            method = Context.getLocalMethod();
-
-        if (fields.exists(method) || method == 'new')
-          for (f in fields)
-            if (f.kind.match(FMethod(MethNormal | MethInline | MethDynamic)))
-              add(f.name, f.type, f.params);
-        for (f in statics)
-          add(f.name, f.type, f.params);
-
-      default:
+      default: te.t.toString();// ewwww
     }
 
-    function add(name, f)
-      if (!localTags.exists(name))
-        localTags[name] = f;
-
-    for (i in Context.getLocalImports())
-      switch i {
-        case { mode: IAll, path: path } if (startsCapital(path[path.length - 1].name)):
-
-          path = path.copy();
-
-          var e = {
-            var first = path.shift();
-            macro @:pos(first.pos) $i{first.name};
-          }
-
-          for (p in path)
-            e = EField(e, p.name).at(p.pos);
-
-          for (t in extractAllFrom(e).get())
-            add(t.name, t.value);
-        default:
-      }
-
-    for (d in defaults.get())
-      if (!localTags.exists(d.name))
-        localTags[d.name] = d.value;
-    return localTags;
+    return switch cache[key] {
+      case null: cache[key] = declaration(name.value, name.pos, t, params);
+      case v: v;
+    }
   }
 
-  static function makeArgs(pos:Position, name:String, t:Type, params:Array<TypeParameter>, ?children:Type):TagArgs {
-    function anon(anon:AnonType, t, lift:Bool, children:Type):TagArgs {
+  static function makeArgs(pos:Position, name:String, t:Type, ?children:Type):TagArgs & { children:Type } {
+    function anon(anon:AnonType, t, lift:Bool, children:Type):TagArgs & { children:Type } {
       var fields = new Map(),
           aliases = new Map(),
           custom:Array<CustomAttr> = [];
@@ -138,7 +109,7 @@ using StringTools;
             switch expr.expr {
               case EConst(CRegexp(pat, opt)):
                 custom.push({
-                  type: f.type.toComplex(),
+                  type: f.type.toComplex({ direct: true }),
                   group: if (f.name == '') None else Some(f.name),
                   filter: new EReg(pat, opt),
                 });
@@ -237,9 +208,8 @@ using StringTools;
     }
   }
 
-  static public function declaration(name:String, pos:Position, type:Type, params:Array<TypeParameter>, ?isVoid:Bool):Tag {
-
-    function mk(args, create, callee, params, ?realPath):Tag {
+  static function declaration(name:String, pos:Position, type:Type, params:Array<TypeParameter>, ?isVoid:Bool):Tag {
+    function mk(args, create, callee, params:Array<TypeParameter>, ?realPath):Tag {
       if (false)
         TFun(args, null);//force inference
 
@@ -281,7 +251,7 @@ using StringTools;
         default: reject('defines too many arguments');
       }
 
-      var args = makeArgs(pos, name, attr, params, children);
+      var args = makeArgs(pos, name, attr, children);
       for (keys in [args.aliases.keys(), args.fields.keys()])
         for (k in keys)
           if (hxxMeta.exists(k))
@@ -302,14 +272,20 @@ using StringTools;
             var ret = {
               fieldsType: args.fieldsType.toComplex({ direct: true }),
               requiredFields: RStatic(Macro.fieldsToInfos(args.fields)),
+              children: args.children,
             }
             function () return ret;
           default:
             function () {
-              var ct = args.fieldsType.reduce().applyTypeParameters(params, [for (t in params) Context.typeof(macro cast null)]).toComplex({ direct: true });
+              var monos = [for (t in params) Context.typeof(macro cast null)];
+              var ct = args.fieldsType.reduce().applyTypeParameters(params, monos).toComplex({ direct: true });
               var placeholder = macro (cast null : $ct);
               return {
                 fieldsType: ct,
+                children: switch args.children {
+                  case null: null;
+                  case t: t.applyTypeParameters(params, monos);
+                },
                 requiredFields: RStatic(Macro.fieldsToInfos(
                   args.fields,
                   function (f) {
@@ -342,6 +318,8 @@ using StringTools;
         case TInst(cl, _) | TAbstract(_.get().impl => cl, _) if (cl != null):
           var cl = cl.get();
 
+          if (!cl.isPrivate) name = if (cl.module.endsWith(cl.name)) cl.module else '${cl.module}.${cl.name}';
+
           var options = [FromHxx, New],
               ret = null,
               isAbstract = cl.kind.match(KAbstractImpl(_));
@@ -359,7 +337,6 @@ using StringTools;
                 case v:
                   throw 'assert $v';
               }
-
           switch cl.findField('fromHxx', true) {
             case null:
               switch getCtor() {
@@ -394,7 +371,7 @@ using StringTools;
       return
         switch Context.typeof(macro @:pos(pos) ${name.resolve()}.fromHxx).reduce() {
           case TFun(args, _):
-            mk(args, Call, name, [], '$name.fromHxx');
+            mk(args, Call, name, params, '$name.fromHxx');
           case v:
             pos.error('$name.fromHxx should be a function, but it is a ${v.toString()}');
         }
@@ -406,7 +383,7 @@ using StringTools;
         case TType(_.get() => { pack: [], name: t }, []) if (t.startsWith('Class<') || t.startsWith('Enum<')):
           return fromType(Context.getType(name));
         case TFun(args, _):
-          return mk(args, Call, name, []);
+          return mk(args, Call, name, params);
         case TLazy(_) | TType(_):
           type = type.reduce(true);
         case TInst(_) | TAnonymous(_) if (hasField('fromHxx')):
@@ -417,61 +394,12 @@ using StringTools;
           pos.error('$name has type ${orig.toString()} which is unsuitable for HXX');
       }
   }
-
-  static public function extractAllFrom(e:Expr):Lazy<Array<Named<Position->Tag>>> {
-    return function () {
-      var name = {
-
-        var cur = e,
-            ret = [];
-
-        while (true) switch cur {
-          case macro @:pos(p) $v.$name:
-            cur = v;
-            ret.push(name);
-          case macro $i{name}:
-            ret.push(name);
-            break;
-          default: cur.reject('dot path expected');
-        }
-
-        ret.reverse();
-        ret.join('.');
-      }
-
-      var tags = [];
-      for (f in e.typeof().sure().getFields().sure())
-        if (f.isPublic) switch f.kind {
-          case FMethod(MethMacro): continue; //TODO: consider treating these as opaque tags
-          case FMethod(_):
-            var decl = null;
-            function make(pos) {
-              if (decl == null)
-                decl = declaration('$name.${f.name}', pos, f.type, f.params, f.meta.extract(':voidTag').length > 0);
-              return decl;
-            }
-
-            function add(name)
-              tags.push(new Named(name, make));
-
-            add(f.name);
-
-            for (m in f.meta.extract(':hxx'))
-              for (v in m.params) add(v.getString().sure());
-
-          default: continue;
-        }
-      return tags;
-    }
-  }
-
 }
 
 typedef TagArgs = {
   var aliases(default, never):Map<String, String>;//TODO: consider putting aliases straight into fields
   var fields(default, never):Map<String, ClassField>;
   var fieldsType(default, never):Type;
-  var children(default, never):Type;
   var childrenAttribute(default, never):Null<String>;
   var custom(default, never):Array<CustomAttr>;
 }
diff --git a/tests/Dummy.hx b/tests/Dummy.hx
index c2b58b3..01ae934 100644
--- a/tests/Dummy.hx
+++ b/tests/Dummy.hx
@@ -64,10 +64,6 @@ abstract Dummy({ name:String, attr:DynamicAccess<AttrVal>, children:Children })
           e,
           {
             defaultExtension: 'hxx',
-            isVoid: function (s) return switch s.value {
-              case 'img': true;
-              default: false;
-            },
             treatNested: gen.root
           }
         )
diff --git a/tests/NonSense.hx b/tests/NonSense.hx
deleted file mode 100644
index db45768..0000000
--- a/tests/NonSense.hx
+++ /dev/null
@@ -1,9 +0,0 @@
-import Tags.*;
-
-class NonSense {
-  static public function showOff() 
-    Plain.hxx(
-      <💩💩💩 🔫🚀🦖="🏃!!!!" /> 
-      //shit, shit, shit!!! laser rocket dinosaurs ... run!!!!
-    );
-}
\ No newline at end of file
diff --git a/tests/Plain.hx b/tests/Plain.hx
index 6a3400f..d3cc32a 100644
--- a/tests/Plain.hx
+++ b/tests/Plain.hx
@@ -13,7 +13,6 @@ class Plain {
         defaultExtension: 'hxx',
         noControlStructures: false,
         defaultSwitchTarget: macro __data__,
-        isVoid: ctx.isVoid,
         fragment: 'Plain.array',
         treatNested: function (children) return ctx.generateRoot.bind(children).bounce(),
       })
diff --git a/tests/RunTests.hx b/tests/RunTests.hx
index 39d8155..466bf8b 100644
--- a/tests/RunTests.hx
+++ b/tests/RunTests.hx
@@ -6,6 +6,11 @@ import tink.testrunner.*;
 import Dummy.*;
 import Tags.*;
 import stuff.Concat;
+#if function_sugar
+using tink.hxx.FunctionSugar;
+#elseif deprecated_function_sugar
+using tink.hxx.DeprecatedFunctionSugar;
+#end
 
 @:asserts
 @:tink
@@ -59,6 +64,22 @@ class RunTests {
     return asserts.done();
   }
 
+  public function issue51() {
+    function button(a:{ ?onclick:Int->Void })
+      return a.onclick;
+
+    #if (function_sugar || deprecated_function_sugar)
+      Plain.hxx('<button onclick=${trace(event)} />');
+    #else
+    asserts.assert(
+      Assert.expectCompilerError(
+        Plain.hxx('<button onclick=${trace(event)} />')
+      ).holds
+    );
+    #end
+    return asserts.done();
+  }
+
   public function splat() {
     var o1 = { foo: 'o1', bar: '123' };
     var o2 = { foo: 'o2', baz: 'o2' };
@@ -80,6 +101,14 @@ class RunTests {
     return asserts.done();
   }
 
+  public function expression() {
+    function button(attr:{ onclick:tink.hxx.Expression<String->Void> })
+      return attr.onclick();
+
+    Plain.hxx('<button onclick=${#if function_sugar trace('clicked!') #else _ -> trace('clicked!') #end} />');
+    return asserts.done();
+  }
+
   public function control() {
     var other = dom('<other/>');
     asserts.assert('<div><zero></zero><one></one><two></two><other></other><other></other></div>' == dom('
@@ -196,6 +225,16 @@ class RunTests {
     return asserts.done();
   }
 
+  function foo<A>(attr:{ a: A, b:Array<A> }):String return 'ok';
+  var bar = (attr:{ a: Int, b:Array<Int> }) -> 'ok';
+
+  public function params() {
+    Plain.hxx('<foo a={true} b={[false]} />');
+    Plain.hxx('<foo a={123} b={[321]} />');
+    Plain.hxx('<bar a={123} b={[321]} />');
+    return asserts.done();
+  }
+
   public function dotPaths() {
     function identity(x)
       return x;
@@ -233,10 +272,6 @@ class RunTests {
   public function inlineMarkup() {
     var a = [for (i in 0...10) '$i'];
 
-    #if tink_parse_unicode
-    NonSense.showOff();
-    #end
-
     Plain.hxx(
       <div key="5">
         {a.map(x -> <div>{x}</div>)}